OLD | NEW |
(Empty) | |
| 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, 2006, 2007, |
| 7 # 2008 Free Software 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 3 of the License, or |
| 12 # (at your option) 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, see <http://www.gnu.org/licenses/>. |
| 21 |
| 22 # As a special exception, the Free Software Foundation gives unlimited |
| 23 # permission to copy, distribute and modify the configure scripts that |
| 24 # are the output of Autoconf. You need not follow the terms of the GNU |
| 25 # General Public License when using or distributing such scripts, even |
| 26 # though portions of the text of Autoconf appear in them. The GNU |
| 27 # General Public License (GPL) does govern all other use of the material |
| 28 # that constitutes the Autoconf program. |
| 29 # |
| 30 # Certain portions of the Autoconf source text are designed to be copied |
| 31 # (in certain cases, depending on the input) into the output of |
| 32 # Autoconf. We call these the "data" portions. The rest of the Autoconf |
| 33 # source text consists of comments plus executable code that decides which |
| 34 # of the data portions to output in any given case. We call these |
| 35 # comments and executable code the "non-data" portions. Autoconf never |
| 36 # copies any of the non-data portions into its output. |
| 37 # |
| 38 # This special exception to the GPL applies to versions of Autoconf |
| 39 # released by the Free Software Foundation. When you make and |
| 40 # distribute a modified version of Autoconf, you may extend this special |
| 41 # exception to the GPL to apply to your modified version as well, *unless* |
| 42 # your modified version has the potential to copy into its output some |
| 43 # of the text that was the non-data portion of the version that you started |
| 44 # with. (In other words, unless your change moves or copies text from |
| 45 # the non-data portions to the data portions.) If your modification has |
| 46 # such potential, you must delete any notice of this special exception |
| 47 # to the GPL from your modified version. |
| 48 # |
| 49 # Written by Akim Demaille. |
| 50 # |
| 51 |
| 52 # Set the quotes, whatever the current quoting system. |
| 53 changequote() |
| 54 changequote([, ]) |
| 55 |
| 56 # Some old m4's don't support m4exit. But they provide |
| 57 # equivalent functionality by core dumping because of the |
| 58 # long macros we define. |
| 59 ifdef([__gnu__], , |
| 60 [errprint(M4sugar requires GNU M4. Install it before installing M4sugar or |
| 61 set the M4 environment variable to its absolute file name.) |
| 62 m4exit(2)]) |
| 63 |
| 64 |
| 65 ## ------------------------------- ## |
| 66 ## 1. Simulate --prefix-builtins. ## |
| 67 ## ------------------------------- ## |
| 68 |
| 69 # m4_define |
| 70 # m4_defn |
| 71 # m4_undefine |
| 72 define([m4_define], defn([define])) |
| 73 define([m4_defn], defn([defn])) |
| 74 define([m4_undefine], defn([undefine])) |
| 75 |
| 76 m4_undefine([define]) |
| 77 m4_undefine([defn]) |
| 78 m4_undefine([undefine]) |
| 79 |
| 80 |
| 81 # m4_copy(SRC, DST) |
| 82 # ----------------- |
| 83 # Define DST as the definition of SRC. |
| 84 # What's the difference between: |
| 85 # 1. m4_copy([from], [to]) |
| 86 # 2. m4_define([to], [from($@)]) |
| 87 # Well, obviously 1 is more expensive in space. Maybe 2 is more expensive |
| 88 # in time, but because of the space cost of 1, it's not that obvious. |
| 89 # Nevertheless, one huge difference is the handling of `$0'. If `from' |
| 90 # uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. |
| 91 # The user would certainly prefer to see `to'. |
| 92 m4_define([m4_copy], |
| 93 [m4_define([$2], m4_defn([$1]))]) |
| 94 |
| 95 |
| 96 # m4_rename(SRC, DST) |
| 97 # ------------------- |
| 98 # Rename the macro SRC to DST. |
| 99 m4_define([m4_rename], |
| 100 [m4_copy([$1], [$2])m4_undefine([$1])]) |
| 101 |
| 102 |
| 103 # m4_rename_m4(MACRO-NAME) |
| 104 # ------------------------ |
| 105 # Rename MACRO-NAME to m4_MACRO-NAME. |
| 106 m4_define([m4_rename_m4], |
| 107 [m4_rename([$1], [m4_$1])]) |
| 108 |
| 109 |
| 110 # m4_copy_unm4(m4_MACRO-NAME) |
| 111 # --------------------------- |
| 112 # Copy m4_MACRO-NAME to MACRO-NAME. |
| 113 m4_define([m4_copy_unm4], |
| 114 [m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) |
| 115 |
| 116 |
| 117 # Some m4 internals have names colliding with tokens we might use. |
| 118 # Rename them a` la `m4 --prefix-builtins'. Conditionals first, since |
| 119 # some subsequent renames are conditional. |
| 120 m4_rename_m4([ifdef]) |
| 121 m4_rename([ifelse], [m4_if]) |
| 122 |
| 123 m4_rename_m4([builtin]) |
| 124 m4_rename_m4([changecom]) |
| 125 m4_rename_m4([changequote]) |
| 126 m4_ifdef([changeword],dnl conditionally available in 1.4.x |
| 127 [m4_undefine([changeword])]) |
| 128 m4_rename_m4([debugfile]) |
| 129 m4_rename_m4([debugmode]) |
| 130 m4_rename_m4([decr]) |
| 131 m4_undefine([divert]) |
| 132 m4_rename_m4([divnum]) |
| 133 m4_rename_m4([dumpdef]) |
| 134 m4_rename_m4([errprint]) |
| 135 m4_rename_m4([esyscmd]) |
| 136 m4_rename_m4([eval]) |
| 137 m4_rename_m4([format]) |
| 138 m4_undefine([include]) |
| 139 m4_rename_m4([incr]) |
| 140 m4_rename_m4([index]) |
| 141 m4_rename_m4([indir]) |
| 142 m4_rename_m4([len]) |
| 143 m4_rename([m4exit], [m4_exit]) |
| 144 m4_undefine([m4wrap]) |
| 145 m4_ifdef([mkstemp],dnl added in M4 1.4.8 |
| 146 [m4_rename_m4([mkstemp]) |
| 147 m4_copy([m4_mkstemp], [m4_maketemp]) |
| 148 m4_undefine([maketemp])], |
| 149 [m4_rename_m4([maketemp]) |
| 150 m4_copy([m4_maketemp], [m4_mkstemp])]) |
| 151 m4_rename([patsubst], [m4_bpatsubst]) |
| 152 m4_rename_m4([popdef]) |
| 153 m4_rename_m4([pushdef]) |
| 154 m4_rename([regexp], [m4_bregexp]) |
| 155 m4_rename_m4([shift]) |
| 156 m4_undefine([sinclude]) |
| 157 m4_rename_m4([substr]) |
| 158 m4_ifdef([symbols],dnl present only in alpha-quality 1.4o |
| 159 [m4_rename_m4([symbols])]) |
| 160 m4_rename_m4([syscmd]) |
| 161 m4_rename_m4([sysval]) |
| 162 m4_rename_m4([traceoff]) |
| 163 m4_rename_m4([traceon]) |
| 164 m4_rename_m4([translit]) |
| 165 m4_undefine([undivert]) |
| 166 |
| 167 |
| 168 ## ------------------- ## |
| 169 ## 2. Error messages. ## |
| 170 ## ------------------- ## |
| 171 |
| 172 |
| 173 # m4_location |
| 174 # ----------- |
| 175 m4_define([m4_location], |
| 176 [__file__:__line__]) |
| 177 |
| 178 |
| 179 # m4_errprintn(MSG) |
| 180 # ----------------- |
| 181 # Same as `errprint', but with the missing end of line. |
| 182 m4_define([m4_errprintn], |
| 183 [m4_errprint([$1 |
| 184 ])]) |
| 185 |
| 186 |
| 187 # m4_warning(MSG) |
| 188 # --------------- |
| 189 # Warn the user. |
| 190 m4_define([m4_warning], |
| 191 [m4_errprintn(m4_location[: warning: $1])]) |
| 192 |
| 193 |
| 194 # m4_fatal(MSG, [EXIT-STATUS]) |
| 195 # ---------------------------- |
| 196 # Fatal the user. :) |
| 197 m4_define([m4_fatal], |
| 198 [m4_errprintn(m4_location[: error: $1])dnl |
| 199 m4_expansion_stack_dump()dnl |
| 200 m4_exit(m4_if([$2],, 1, [$2]))]) |
| 201 |
| 202 |
| 203 # m4_assert(EXPRESSION, [EXIT-STATUS = 1]) |
| 204 # ---------------------------------------- |
| 205 # This macro ensures that EXPRESSION evaluates to true, and exits if |
| 206 # EXPRESSION evaluates to false. |
| 207 m4_define([m4_assert], |
| 208 [m4_if(m4_eval([$1]), 0, |
| 209 [m4_fatal([assert failed: $1], [$2])])]) |
| 210 |
| 211 |
| 212 |
| 213 ## ------------- ## |
| 214 ## 3. Warnings. ## |
| 215 ## ------------- ## |
| 216 |
| 217 |
| 218 # _m4_warn(CATEGORY, MESSAGE, STACK-TRACE) |
| 219 # ---------------------------------------- |
| 220 # Report a MESSAGE to the user if the CATEGORY of warnings is enabled. |
| 221 # This is for traces only. |
| 222 # The STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE". |
| 223 # |
| 224 # Within m4, the macro is a no-op. This macro really matters |
| 225 # when autom4te post-processes the trace output. |
| 226 m4_define([_m4_warn], []) |
| 227 |
| 228 |
| 229 # m4_warn(CATEGORY, MESSAGE) |
| 230 # -------------------------- |
| 231 # Report a MESSAGE to the user if the CATEGORY of warnings is enabled. |
| 232 m4_define([m4_warn], |
| 233 [_m4_warn([$1], [$2], |
| 234 m4_ifdef([m4_expansion_stack], |
| 235 [_m4_defn([m4_expansion_stack]) |
| 236 m4_location[: the top level]]))dnl |
| 237 ]) |
| 238 |
| 239 |
| 240 |
| 241 ## ------------------- ## |
| 242 ## 4. File inclusion. ## |
| 243 ## ------------------- ## |
| 244 |
| 245 |
| 246 # We also want to neutralize include (and sinclude for symmetry), |
| 247 # but we want to extend them slightly: warn when a file is included |
| 248 # several times. This is, in general, a dangerous operation, because |
| 249 # too many people forget to quote the first argument of m4_define. |
| 250 # |
| 251 # For instance in the following case: |
| 252 # m4_define(foo, [bar]) |
| 253 # then a second reading will turn into |
| 254 # m4_define(bar, [bar]) |
| 255 # which is certainly not what was meant. |
| 256 |
| 257 # m4_include_unique(FILE) |
| 258 # ----------------------- |
| 259 # Declare that the FILE was loading; and warn if it has already |
| 260 # been included. |
| 261 m4_define([m4_include_unique], |
| 262 [m4_ifdef([m4_include($1)], |
| 263 [m4_warn([syntax], [file `$1' included several times])])dnl |
| 264 m4_define([m4_include($1)])]) |
| 265 |
| 266 |
| 267 # m4_include(FILE) |
| 268 # ---------------- |
| 269 # Like the builtin include, but warns against multiple inclusions. |
| 270 m4_define([m4_include], |
| 271 [m4_include_unique([$1])dnl |
| 272 m4_builtin([include], [$1])]) |
| 273 |
| 274 |
| 275 # m4_sinclude(FILE) |
| 276 # ----------------- |
| 277 # Like the builtin sinclude, but warns against multiple inclusions. |
| 278 m4_define([m4_sinclude], |
| 279 [m4_include_unique([$1])dnl |
| 280 m4_builtin([sinclude], [$1])]) |
| 281 |
| 282 |
| 283 |
| 284 ## ------------------------------------ ## |
| 285 ## 5. Additional branching constructs. ## |
| 286 ## ------------------------------------ ## |
| 287 |
| 288 # Both `m4_ifval' and `m4_ifset' tests against the empty string. The |
| 289 # difference is that `m4_ifset' is specialized on macros. |
| 290 # |
| 291 # In case of arguments of macros, eg. $1, it makes little difference. |
| 292 # In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, |
| 293 # TRUE)', because if `FOO' expands with commas, there is a shifting of |
| 294 # the arguments. So you want to run `m4_ifval([FOO])', but then you just |
| 295 # compare the *string* `FOO' against `', which, of course fails. |
| 296 # |
| 297 # So you want the variation `m4_ifset' that expects a macro name as $1. |
| 298 # If this macro is both defined and defined to a non empty value, then |
| 299 # it runs TRUE, etc. |
| 300 |
| 301 |
| 302 # m4_ifval(COND, [IF-TRUE], [IF-FALSE]) |
| 303 # ------------------------------------- |
| 304 # If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. |
| 305 # Comparable to m4_ifdef. |
| 306 m4_define([m4_ifval], |
| 307 [m4_if([$1], [], [$3], [$2])]) |
| 308 |
| 309 |
| 310 # m4_n(TEXT) |
| 311 # ---------- |
| 312 # If TEXT is not empty, return TEXT and a new line, otherwise nothing. |
| 313 m4_define([m4_n], |
| 314 [m4_if([$1], |
| 315 [], [], |
| 316 [$1 |
| 317 ])]) |
| 318 |
| 319 |
| 320 # m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) |
| 321 # -------------------------------------- |
| 322 # Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE |
| 323 # unless that argument is empty. |
| 324 m4_define([m4_ifvaln], |
| 325 [m4_if([$1], |
| 326 [], [m4_n([$3])], |
| 327 [m4_n([$2])])]) |
| 328 |
| 329 |
| 330 # m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) |
| 331 # -------------------------------------- |
| 332 # If MACRO has no definition, or of its definition is the empty string, |
| 333 # expand IF-FALSE, otherwise IF-TRUE. |
| 334 m4_define([m4_ifset], |
| 335 [m4_ifdef([$1], |
| 336 [m4_ifval(_m4_defn([$1]), [$2], [$3])], |
| 337 [$3])]) |
| 338 |
| 339 |
| 340 # m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) |
| 341 # ----------------------------------------------- |
| 342 m4_define([m4_ifndef], |
| 343 [m4_ifdef([$1], [$3], [$2])]) |
| 344 |
| 345 |
| 346 # m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) |
| 347 # ----------------------------------------------------------- |
| 348 # m4 equivalent of |
| 349 # switch (SWITCH) |
| 350 # { |
| 351 # case VAL1: |
| 352 # IF-VAL1; |
| 353 # break; |
| 354 # case VAL2: |
| 355 # IF-VAL2; |
| 356 # break; |
| 357 # ... |
| 358 # default: |
| 359 # DEFAULT; |
| 360 # break; |
| 361 # }. |
| 362 # All the values are optional, and the macro is robust to active |
| 363 # symbols properly quoted. |
| 364 # |
| 365 # Please keep foreach.m4 in sync with any adjustments made here. |
| 366 m4_define([m4_case], |
| 367 [m4_if([$#], 0, [], |
| 368 [$#], 1, [], |
| 369 [$#], 2, [$2], |
| 370 [$1], [$2], [$3], |
| 371 [$0([$1], m4_shift3($@))])]) |
| 372 |
| 373 |
| 374 # m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) |
| 375 # ----------------------------------------------------- |
| 376 # m4 equivalent of |
| 377 # |
| 378 # if (SWITCH =~ RE1) |
| 379 # VAL1; |
| 380 # elif (SWITCH =~ RE2) |
| 381 # VAL2; |
| 382 # elif ... |
| 383 # ... |
| 384 # else |
| 385 # DEFAULT |
| 386 # |
| 387 # All the values are optional, and the macro is robust to active symbols |
| 388 # properly quoted. |
| 389 # |
| 390 # Please keep foreach.m4 in sync with any adjustments made here. |
| 391 m4_define([m4_bmatch], |
| 392 [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], |
| 393 [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], |
| 394 [$#], 2, [$2], |
| 395 [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], |
| 396 [$3])])]) |
| 397 |
| 398 |
| 399 # m4_car(LIST) |
| 400 # m4_cdr(LIST) |
| 401 # ------------ |
| 402 # Manipulate m4 lists. |
| 403 m4_define([m4_car], [[$1]]) |
| 404 m4_define([m4_cdr], |
| 405 [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], |
| 406 [$#], 1, [], |
| 407 [m4_dquote(m4_shift($@))])]) |
| 408 |
| 409 # _m4_cdr(LIST) |
| 410 # ------------- |
| 411 # Like m4_cdr, except include a leading comma unless only one element |
| 412 # remains. Why? Because comparing a large list against [] is more |
| 413 # expensive in expansion time than comparing the number of arguments; so |
| 414 # _m4_cdr can be used to reduce the number of arguments when it is time |
| 415 # to end recursion. |
| 416 m4_define([_m4_cdr], |
| 417 [m4_if([$#], 1, [], |
| 418 [, m4_dquote(m4_shift($@))])]) |
| 419 |
| 420 |
| 421 |
| 422 # m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) |
| 423 # ------------------------------------------------------------------- |
| 424 # Similar to m4_if, except that each TEST is expanded when encountered. |
| 425 # If the expansion of TESTn matches the string VALn, the result is IF-VALn. |
| 426 # The result is DEFAULT if no tests passed. This macro allows |
| 427 # short-circuiting of expensive tests, where it pays to arrange quick |
| 428 # filter tests to run first. |
| 429 # |
| 430 # For an example, consider a previous implementation of _AS_QUOTE_IFELSE: |
| 431 # |
| 432 # m4_if(m4_index([$1], [\]), [-1], [$2], |
| 433 # m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], |
| 434 # m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], |
| 435 # m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], |
| 436 # m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], |
| 437 # [$2]) |
| 438 # |
| 439 # Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains |
| 440 # no backslash. It is more efficient to do: |
| 441 # |
| 442 # m4_cond([m4_index([$1], [\])], [-1], [$2], |
| 443 # [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], |
| 444 # [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], |
| 445 # [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], |
| 446 # [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], |
| 447 # [$2]) |
| 448 # |
| 449 # In the common case of $1 with no backslash, only one m4_index expansion |
| 450 # occurs, and m4_eval is avoided altogether. |
| 451 # |
| 452 # Please keep foreach.m4 in sync with any adjustments made here. |
| 453 m4_define([m4_cond], |
| 454 [m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], |
| 455 [$#], [1], [$1], |
| 456 m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], |
| 457 [_$0($@)])]) |
| 458 |
| 459 m4_define([_m4_cond], |
| 460 [m4_if(($1), [($2)], [$3], |
| 461 [$#], [3], [], |
| 462 [$#], [4], [$4], |
| 463 [$0(m4_shift3($@))])]) |
| 464 |
| 465 |
| 466 ## ---------------------------------------- ## |
| 467 ## 6. Enhanced version of some primitives. ## |
| 468 ## ---------------------------------------- ## |
| 469 |
| 470 # m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) |
| 471 # ---------------------------------------------------- |
| 472 # m4 equivalent of |
| 473 # |
| 474 # $_ = STRING; |
| 475 # s/RE1/SUBST1/g; |
| 476 # s/RE2/SUBST2/g; |
| 477 # ... |
| 478 # |
| 479 # All the values are optional, and the macro is robust to active symbols |
| 480 # properly quoted. |
| 481 # |
| 482 # I would have liked to name this macro `m4_bpatsubst', unfortunately, |
| 483 # due to quotation problems, I need to double quote $1 below, therefore |
| 484 # the anchors are broken :( I can't let users be trapped by that. |
| 485 # |
| 486 # Recall that m4_shift3 always results in an argument. Hence, we need |
| 487 # to distinguish between a final deletion vs. ending recursion. |
| 488 # |
| 489 # Please keep foreach.m4 in sync with any adjustments made here. |
| 490 m4_define([m4_bpatsubsts], |
| 491 [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], |
| 492 [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], |
| 493 [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], |
| 494 [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], |
| 495 [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) |
| 496 m4_define([_m4_bpatsubsts], |
| 497 [m4_if([$#], 2, [$1], |
| 498 [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), |
| 499 m4_shift3($@))])]) |
| 500 |
| 501 |
| 502 # m4_define_default(MACRO, VALUE) |
| 503 # ------------------------------- |
| 504 # If MACRO is undefined, set it to VALUE. |
| 505 m4_define([m4_define_default], |
| 506 [m4_ifndef([$1], [m4_define($@)])]) |
| 507 |
| 508 |
| 509 # m4_default(EXP1, EXP2) |
| 510 # ---------------------- |
| 511 # Returns EXP1 if non empty, otherwise EXP2. |
| 512 # |
| 513 # This macro is called on hot paths, so inline the contents of m4_ifval, |
| 514 # for one less round of expansion. |
| 515 m4_define([m4_default], |
| 516 [m4_if([$1], [], [$2], [$1])]) |
| 517 |
| 518 |
| 519 # m4_defn(NAME) |
| 520 # ------------- |
| 521 # Like the original, except guarantee a warning when using something which is |
| 522 # undefined (unlike M4 1.4.x). This replacement is not a full-featured |
| 523 # replacement: if any of the defined macros contain unbalanced quoting, but |
| 524 # when pasted together result in a well-quoted string, then only native m4 |
| 525 # support is able to get it correct. But that's where quadrigraphs come in |
| 526 # handy, if you really need unbalanced quotes inside your macros. |
| 527 # |
| 528 # This macro is called frequently, so minimize the amount of additional |
| 529 # expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, |
| 530 # (added in M4 1.6), then let m4 do the job for us (see m4_init). |
| 531 # |
| 532 # _m4_defn is for internal use only - it bypasses the wrapper, so it |
| 533 # must only be used on one argument at a time, and only on macros |
| 534 # known to be defined. Make sure this still works if the user renames |
| 535 # m4_defn but not _m4_defn. |
| 536 m4_copy([m4_defn], [_m4_defn]) |
| 537 m4_define([m4_defn], |
| 538 [m4_if([$#], [0], [[$0]], |
| 539 [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], |
| 540 [m4_fatal([$0: undefined macro: $1])])], |
| 541 [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) |
| 542 |
| 543 |
| 544 # _m4_dumpdefs_up(NAME) |
| 545 # --------------------- |
| 546 m4_define([_m4_dumpdefs_up], |
| 547 [m4_ifdef([$1], |
| 548 [m4_pushdef([_m4_dumpdefs], _m4_defn([$1]))dnl |
| 549 m4_dumpdef([$1])dnl |
| 550 _m4_popdef([$1])dnl |
| 551 _m4_dumpdefs_up([$1])])]) |
| 552 |
| 553 |
| 554 # _m4_dumpdefs_down(NAME) |
| 555 # ----------------------- |
| 556 m4_define([_m4_dumpdefs_down], |
| 557 [m4_ifdef([_m4_dumpdefs], |
| 558 [m4_pushdef([$1], _m4_defn([_m4_dumpdefs]))dnl |
| 559 _m4_popdef([_m4_dumpdefs])dnl |
| 560 _m4_dumpdefs_down([$1])])]) |
| 561 |
| 562 |
| 563 # m4_dumpdefs(NAME) |
| 564 # ----------------- |
| 565 # Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its |
| 566 # value stack (most recent displayed first). |
| 567 m4_define([m4_dumpdefs], |
| 568 [_m4_dumpdefs_up([$1])dnl |
| 569 _m4_dumpdefs_down([$1])]) |
| 570 |
| 571 |
| 572 # m4_popdef(NAME) |
| 573 # --------------- |
| 574 # Like the original, except guarantee a warning when using something which is |
| 575 # undefined (unlike M4 1.4.x). |
| 576 # |
| 577 # This macro is called frequently, so minimize the amount of additional |
| 578 # expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, |
| 579 # (added in M4 1.6), then let m4 do the job for us (see m4_init). |
| 580 # |
| 581 # _m4_popdef is for internal use only - it bypasses the wrapper, so it |
| 582 # must only be used on macros known to be defined. Make sure this |
| 583 # still works if the user renames m4_popdef but not _m4_popdef. |
| 584 m4_copy([m4_popdef], [_m4_popdef]) |
| 585 m4_define([m4_popdef], |
| 586 [m4_if([$#], [0], [[$0]], |
| 587 [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], |
| 588 [m4_fatal([$0: undefined macro: $1])])], |
| 589 [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) |
| 590 |
| 591 |
| 592 # m4_shiftn(N, ...) |
| 593 # ----------------- |
| 594 # Returns ... shifted N times. Useful for recursive "varargs" constructs. |
| 595 # |
| 596 # Autoconf does not use this macro, because it is inherently slower than |
| 597 # calling the common cases of m4_shift2 or m4_shift3 directly. But it |
| 598 # might as well be fast for other clients, such as Libtool. One way to |
| 599 # do this is to expand $@ only once in _m4_shiftn (otherwise, for long |
| 600 # lists, the expansion of m4_if takes twice as much memory as what the |
| 601 # list itself occupies, only to throw away the unused branch). The end |
| 602 # result is strictly equivalent to |
| 603 # m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], |
| 604 # [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) |
| 605 # but with the final `m4_shift(m4_shift($@)))' shared between the two |
| 606 # paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). |
| 607 # |
| 608 # Please keep foreach.m4 in sync with any adjustments made here. |
| 609 m4_define([m4_shiftn], |
| 610 [m4_assert(0 < $1 && $1 < $#)_$0($@)]) |
| 611 |
| 612 m4_define([_m4_shiftn], |
| 613 [m4_if([$1], 1, [m4_shift(], |
| 614 [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) |
| 615 |
| 616 # m4_shift2(...) |
| 617 # m4_shift3(...) |
| 618 # ----------------- |
| 619 # Returns ... shifted twice, and three times. Faster than m4_shiftn. |
| 620 m4_define([m4_shift2], [m4_shift(m4_shift($@))]) |
| 621 m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) |
| 622 |
| 623 # _m4_shift2(...) |
| 624 # _m4_shift3(...) |
| 625 # --------------- |
| 626 # Like m4_shift2 or m4_shift3, except include a leading comma unless shifting |
| 627 # consumes all arguments. Why? Because in recursion, it is nice to |
| 628 # distinguish between 1 element left and 0 elements left, based on how many |
| 629 # arguments this shift expands to. |
| 630 m4_define([_m4_shift2], |
| 631 [m4_if([$#], [2], [], |
| 632 [, m4_shift(m4_shift($@))])]) |
| 633 m4_define([_m4_shift3], |
| 634 [m4_if([$#], [3], [], |
| 635 [, m4_shift(m4_shift(m4_shift($@)))])]) |
| 636 |
| 637 |
| 638 # m4_undefine(NAME) |
| 639 # ----------------- |
| 640 # Like the original, except guarantee a warning when using something which is |
| 641 # undefined (unlike M4 1.4.x). |
| 642 # |
| 643 # This macro is called frequently, so minimize the amount of additional |
| 644 # expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, |
| 645 # (added in M4 1.6), then let m4 do the job for us (see m4_init). |
| 646 # |
| 647 # _m4_undefine is for internal use only - it bypasses the wrapper, so |
| 648 # it must only be used on macros known to be defined. Make sure this |
| 649 # still works if the user renames m4_undefine but not _m4_undefine. |
| 650 m4_copy([m4_undefine], [_m4_undefine]) |
| 651 m4_define([m4_undefine], |
| 652 [m4_if([$#], [0], [[$0]], |
| 653 [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], |
| 654 [m4_fatal([$0: undefined macro: $1])])], |
| 655 [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) |
| 656 |
| 657 # _m4_wrap(PRE, POST) |
| 658 # ------------------- |
| 659 # Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to |
| 660 # m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. |
| 661 m4_define([_m4_wrap], |
| 662 [m4_ifdef([$0_text], |
| 663 [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], |
| 664 [m4_builtin([m4wrap], [m4_unquote( |
| 665 _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) |
| 666 |
| 667 # m4_wrap(TEXT) |
| 668 # ------------- |
| 669 # Append TEXT to the list of hooks to be executed at the end of input. |
| 670 # Whereas the order of the original may be LIFO in the underlying m4, |
| 671 # this version is always FIFO. |
| 672 m4_define([m4_wrap], |
| 673 [_m4_wrap([], [$1[]])]) |
| 674 |
| 675 # m4_wrap_lifo(TEXT) |
| 676 # ------------------ |
| 677 # Prepend TEXT to the list of hooks to be executed at the end of input. |
| 678 # Whereas the order of m4_wrap may be FIFO in the underlying m4, this |
| 679 # version is always LIFO. |
| 680 m4_define([m4_wrap_lifo], |
| 681 [_m4_wrap([$1[]])]) |
| 682 |
| 683 ## ------------------------- ## |
| 684 ## 7. Quoting manipulation. ## |
| 685 ## ------------------------- ## |
| 686 |
| 687 |
| 688 # m4_apply(MACRO, LIST) |
| 689 # --------------------- |
| 690 # Invoke MACRO, with arguments provided from the quoted list of |
| 691 # comma-separated quoted arguments. If LIST is empty, invoke MACRO |
| 692 # without arguments. The expansion will not be concatenated with |
| 693 # subsequent text. |
| 694 m4_define([m4_apply], |
| 695 [m4_if([$2], [], [$1], [$1($2)])[]]) |
| 696 |
| 697 # _m4_apply(MACRO, LIST) |
| 698 # ---------------------- |
| 699 # Like m4_apply, except do nothing if LIST is empty. |
| 700 m4_define([_m4_apply], |
| 701 [m4_if([$2], [], [], [$1($2)[]])]) |
| 702 |
| 703 |
| 704 # m4_count(ARGS) |
| 705 # -------------- |
| 706 # Return a count of how many ARGS are present. |
| 707 m4_define([m4_count], [$#]) |
| 708 |
| 709 |
| 710 # m4_do(STRING, ...) |
| 711 # ------------------ |
| 712 # This macro invokes all its arguments (in sequence, of course). It is |
| 713 # useful for making your macros more structured and readable by dropping |
| 714 # unnecessary dnl's and have the macros indented properly. No concatenation |
| 715 # occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. |
| 716 # |
| 717 # Please keep foreach.m4 in sync with any adjustments made here. |
| 718 m4_define([m4_do], |
| 719 [m4_if([$#], 0, [], |
| 720 [$#], 1, [$1[]], |
| 721 [$1[]$0(m4_shift($@))])]) |
| 722 |
| 723 |
| 724 # m4_dquote(ARGS) |
| 725 # --------------- |
| 726 # Return ARGS as a quoted list of quoted arguments. |
| 727 m4_define([m4_dquote], [[$@]]) |
| 728 |
| 729 |
| 730 # m4_dquote_elt(ARGS) |
| 731 # ------------------- |
| 732 # Return ARGS as an unquoted list of double-quoted arguments. |
| 733 # |
| 734 # Please keep foreach.m4 in sync with any adjustments made here. |
| 735 m4_define([m4_dquote_elt], |
| 736 [m4_if([$#], [0], [], |
| 737 [$#], [1], [[[$1]]], |
| 738 [[[$1]],$0(m4_shift($@))])]) |
| 739 |
| 740 |
| 741 # m4_echo(ARGS) |
| 742 # ------------- |
| 743 # Return the ARGS, with the same level of quoting. Whitespace after |
| 744 # unquoted commas are consumed. |
| 745 m4_define([m4_echo], [$@]) |
| 746 |
| 747 |
| 748 # m4_expand(ARG) |
| 749 # -------------- |
| 750 # Return the expansion of ARG as a single string. Unlike m4_quote($1), this |
| 751 # correctly preserves whitespace following single-quoted commas that appeared |
| 752 # within ARG. |
| 753 # |
| 754 # m4_define([active], [ACT, IVE]) |
| 755 # m4_define([active2], [[ACT, IVE]]) |
| 756 # m4_quote(active, active2) |
| 757 # => ACT,IVE,ACT, IVE |
| 758 # m4_expand([active, active2]) |
| 759 # => ACT, IVE, ACT, IVE |
| 760 # |
| 761 # Unfortunately, due to limitations in m4, ARG must expand to something |
| 762 # with balanced quotes (use quadrigraphs to get around this). The input |
| 763 # is not likely to have unbalanced -=<{(/)}>=- quotes, and it is possible |
| 764 # to have unbalanced (), provided it was specified with proper [] quotes. |
| 765 # |
| 766 # Exploit that extra () will group unquoted commas and the following |
| 767 # whitespace, then convert () to []. m4_bpatsubst can't handle newlines |
| 768 # inside $1, and m4_substr strips quoting. So we (ab)use m4_changequote. |
| 769 m4_define([m4_expand], [_$0(-=<{($1)}>=-)]) |
| 770 m4_define([_m4_expand], |
| 771 [m4_changequote([-=<{(], [)}>=-])$1m4_changequote([, ])]) |
| 772 |
| 773 |
| 774 # m4_ignore(ARGS) |
| 775 # --------------- |
| 776 # Expands to nothing. Useful for conditionally ignoring an arbitrary |
| 777 # number of arguments (see _m4_list_cmp for an example). |
| 778 m4_define([m4_ignore]) |
| 779 |
| 780 |
| 781 # m4_make_list(ARGS) |
| 782 # ------------------ |
| 783 # Similar to m4_dquote, this creates a quoted list of quoted ARGS. This |
| 784 # version is less efficient than m4_dquote, but separates each argument |
| 785 # with a comma and newline, rather than just comma, for readability. |
| 786 # When developing an m4sugar algorithm, you could temporarily use |
| 787 # m4_pushdef([m4_dquote],m4_defn([m4_make_list])) |
| 788 # around your code to make debugging easier. |
| 789 m4_define([m4_make_list], [m4_join([, |
| 790 ], m4_dquote_elt($@))]) |
| 791 |
| 792 |
| 793 # m4_noquote(STRING) |
| 794 # ------------------ |
| 795 # Return the result of ignoring all quotes in STRING and invoking the |
| 796 # macros it contains. Amongst other things, this is useful for enabling |
| 797 # macro invocations inside strings with [] blocks (for instance regexps |
| 798 # and help-strings). On the other hand, since all quotes are disabled, |
| 799 # any macro expanded during this time that relies on nested [] quoting |
| 800 # will likely crash and burn. This macro is seldom useful; consider |
| 801 # m4_unquote or m4_expand instead. |
| 802 m4_define([m4_noquote], |
| 803 [m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) |
| 804 |
| 805 |
| 806 # m4_quote(ARGS) |
| 807 # -------------- |
| 808 # Return ARGS as a single argument. Any whitespace after unquoted commas |
| 809 # is stripped. There is always output, even when there were no arguments. |
| 810 # |
| 811 # It is important to realize the difference between `m4_quote(exp)' and |
| 812 # `[exp]': in the first case you obtain the quoted *result* of the |
| 813 # expansion of EXP, while in the latter you just obtain the string |
| 814 # `exp'. |
| 815 m4_define([m4_quote], [[$*]]) |
| 816 |
| 817 |
| 818 # _m4_quote(ARGS) |
| 819 # --------------- |
| 820 # Like m4_quote, except that when there are no arguments, there is no |
| 821 # output. For conditional scenarios (such as passing _m4_quote as the |
| 822 # macro name in m4_mapall), this feature can be used to distinguish between |
| 823 # one argument of the empty string vs. no arguments. However, in the |
| 824 # normal case with arguments present, this is less efficient than m4_quote. |
| 825 m4_define([_m4_quote], |
| 826 [m4_if([$#], [0], [], [[$*]])]) |
| 827 |
| 828 |
| 829 # m4_reverse(ARGS) |
| 830 # ---------------- |
| 831 # Output ARGS in reverse order. |
| 832 # |
| 833 # Please keep foreach.m4 in sync with any adjustments made here. |
| 834 m4_define([m4_reverse], |
| 835 [m4_if([$#], [0], [], [$#], [1], [[$1]], |
| 836 [$0(m4_shift($@)), [$1]])]) |
| 837 |
| 838 |
| 839 # m4_unquote(ARGS) |
| 840 # ---------------- |
| 841 # Remove one layer of quotes from each ARG, performing one level of |
| 842 # expansion. For one argument, m4_unquote([arg]) is more efficient than |
| 843 # m4_do([arg]), but for multiple arguments, the difference is that |
| 844 # m4_unquote separates arguments with commas while m4_do concatenates. |
| 845 # Follow this macro with [] if concatenation with subsequent text is |
| 846 # undesired. |
| 847 m4_define([m4_unquote], [$*]) |
| 848 |
| 849 |
| 850 ## -------------------------- ## |
| 851 ## 8. Implementing m4 loops. ## |
| 852 ## -------------------------- ## |
| 853 |
| 854 |
| 855 # m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) |
| 856 # -------------------------------------------------------- |
| 857 # Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with |
| 858 # increments of STEP. Both limits are included, and bounds are |
| 859 # checked for consistency. The algorithm is robust to indirect |
| 860 # VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact |
| 861 # the number of iterations. |
| 862 # |
| 863 # Uses _m4_defn for speed, and avoid dnl in the macro body. |
| 864 m4_define([m4_for], |
| 865 [m4_pushdef([$1], m4_eval([$2]))]dnl |
| 866 [m4_cond([m4_eval(([$3]) > ([$2]))], 1, |
| 867 [m4_pushdef([_m4_step], m4_eval(m4_default([$4], |
| 868 1)))m4_assert(_m4_step > 0)_$0([$1], _m4_defn([$1]), |
| 869 m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), |
| 870 _m4_step, [$5])], |
| 871 [m4_eval(([$3]) < ([$2]))], 1, |
| 872 [m4_pushdef([_m4_step], m4_eval(m4_default([$4], |
| 873 -1)))m4_assert(_m4_step < 0)_$0([$1], _m4_defn([$1]), |
| 874 m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), |
| 875 _m4_step, [$5])], |
| 876 [m4_pushdef([_m4_step])$5])[]]dnl |
| 877 [m4_popdef([_m4_step], [$1])]) |
| 878 |
| 879 |
| 880 # _m4_for(VARIABLE, COUNT, LAST, STEP, EXPRESSION) |
| 881 # ------------------------------------------------ |
| 882 # Core of the loop, no consistency checks, all arguments are plain |
| 883 # numbers. Define VARIABLE to COUNT, expand EXPRESSION, then alter |
| 884 # COUNT by STEP and iterate if COUNT is not LAST. |
| 885 m4_define([_m4_for], |
| 886 [m4_define([$1], [$2])$5[]m4_if([$2], [$3], [], |
| 887 [$0([$1], m4_eval([$2 + $4]), [$3], [$4], [$5])])]) |
| 888 |
| 889 |
| 890 # Implementing `foreach' loops in m4 is much more tricky than it may |
| 891 # seem. For example, the old M4 1.4.4 manual had an incorrect example, |
| 892 # which looked like this (when translated to m4sugar): |
| 893 # |
| 894 # | # foreach(VAR, (LIST), STMT) |
| 895 # | m4_define([foreach], |
| 896 # | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) |
| 897 # | m4_define([_arg1], [$1]) |
| 898 # | m4_define([_foreach], |
| 899 # | [m4_if([$2], [()], , |
| 900 # | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) |
| 901 # |
| 902 # But then if you run |
| 903 # |
| 904 # | m4_define(a, 1) |
| 905 # | m4_define(b, 2) |
| 906 # | m4_define(c, 3) |
| 907 # | foreach([f], [([a], [(b], [c)])], [echo f |
| 908 # | ]) |
| 909 # |
| 910 # it gives |
| 911 # |
| 912 # => echo 1 |
| 913 # => echo (2,3) |
| 914 # |
| 915 # which is not what is expected. |
| 916 # |
| 917 # Of course the problem is that many quotes are missing. So you add |
| 918 # plenty of quotes at random places, until you reach the expected |
| 919 # result. Alternatively, if you are a quoting wizard, you directly |
| 920 # reach the following implementation (but if you really did, then |
| 921 # apply to the maintenance of m4sugar!). |
| 922 # |
| 923 # | # foreach(VAR, (LIST), STMT) |
| 924 # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) |
| 925 # | m4_define([_arg1], [[$1]]) |
| 926 # | m4_define([_foreach], |
| 927 # | [m4_if($2, [()], , |
| 928 # | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) |
| 929 # |
| 930 # which this time answers |
| 931 # |
| 932 # => echo a |
| 933 # => echo (b |
| 934 # => echo c) |
| 935 # |
| 936 # Bingo! |
| 937 # |
| 938 # Well, not quite. |
| 939 # |
| 940 # With a better look, you realize that the parens are more a pain than |
| 941 # a help: since anyway you need to quote properly the list, you end up |
| 942 # with always using an outermost pair of parens and an outermost pair |
| 943 # of quotes. Rejecting the parens both eases the implementation, and |
| 944 # simplifies the use: |
| 945 # |
| 946 # | # foreach(VAR, (LIST), STMT) |
| 947 # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) |
| 948 # | m4_define([_arg1], [$1]) |
| 949 # | m4_define([_foreach], |
| 950 # | [m4_if($2, [], , |
| 951 # | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) |
| 952 # |
| 953 # |
| 954 # Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' |
| 955 # to improve robustness, and you come up with a nice implementation |
| 956 # that doesn't require extra parentheses in the user's LIST. |
| 957 # |
| 958 # But wait - now the algorithm is quadratic, because every recursion of |
| 959 # the algorithm keeps the entire LIST and merely adds another m4_shift to |
| 960 # the quoted text. If the user has a lot of elements in LIST, you can |
| 961 # bring the system to its knees with the memory m4 then requires, or trip |
| 962 # the m4 --nesting-limit recursion factor. The only way to avoid |
| 963 # quadratic growth is ensure m4_shift is expanded prior to the recursion. |
| 964 # Hence the design below. |
| 965 # |
| 966 # The M4 manual now includes a chapter devoted to this issue, with |
| 967 # the lessons learned from m4sugar. And still, this design is only |
| 968 # optimal for M4 1.6; see foreach.m4 for yet more comments on why |
| 969 # M4 1.4.x uses yet another implementation. |
| 970 |
| 971 |
| 972 # m4_foreach(VARIABLE, LIST, EXPRESSION) |
| 973 # -------------------------------------- |
| 974 # |
| 975 # Expand EXPRESSION assigning each value of the LIST to VARIABLE. |
| 976 # LIST should have the form `item_1, item_2, ..., item_n', i.e. the |
| 977 # whole list must *quoted*. Quote members too if you don't want them |
| 978 # to be expanded. |
| 979 # |
| 980 # This macro is robust to active symbols: |
| 981 # | m4_define(active, [ACT, IVE]) |
| 982 # | m4_foreach(Var, [active, active], [-Var-]) |
| 983 # => -ACT--IVE--ACT--IVE- |
| 984 # |
| 985 # | m4_foreach(Var, [[active], [active]], [-Var-]) |
| 986 # => -ACT, IVE--ACT, IVE- |
| 987 # |
| 988 # | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) |
| 989 # => -active--active- |
| 990 # |
| 991 # This macro is called frequently, so avoid extra expansions such as |
| 992 # m4_ifval and dnl. Also, since $2 might be quite large, try to use it |
| 993 # as little as possible in _m4_foreach; each extra use requires that much |
| 994 # more memory for expansion. So, rather than directly compare $2 against |
| 995 # [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which |
| 996 # requires swapping the argument order in the helper), insert an ignored |
| 997 # third argument, and use m4_shift3 to detect when recursion is complete. |
| 998 # |
| 999 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1000 m4_define([m4_foreach], |
| 1001 [m4_if([$2], [], [], |
| 1002 [m4_pushdef([$1])_$0([$1], [$3], [], $2)m4_popdef([$1])])]) |
| 1003 |
| 1004 m4_define([_m4_foreach], |
| 1005 [m4_if([$#], [3], [], |
| 1006 [m4_define([$1], [$4])$2[]$0([$1], [$2], m4_shift3($@))])]) |
| 1007 |
| 1008 |
| 1009 # m4_foreach_w(VARIABLE, LIST, EXPRESSION) |
| 1010 # ---------------------------------------- |
| 1011 # |
| 1012 # Like m4_foreach, but the list is whitespace separated. |
| 1013 # |
| 1014 # This macro is robust to active symbols: |
| 1015 # m4_foreach_w([Var], [ active |
| 1016 # b act\ |
| 1017 # ive ], [-Var-])end |
| 1018 # => -active--b--active-end |
| 1019 # |
| 1020 m4_define([m4_foreach_w], |
| 1021 [m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])]) |
| 1022 |
| 1023 |
| 1024 # m4_map(MACRO, LIST) |
| 1025 # m4_mapall(MACRO, LIST) |
| 1026 # ---------------------- |
| 1027 # Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of |
| 1028 # LIST. $1, $2... must in turn be lists, appropriate for m4_apply. |
| 1029 # If LIST contains an empty sublist, m4_map skips the expansion of |
| 1030 # MACRO, while m4_mapall expands MACRO with no arguments. |
| 1031 # |
| 1032 # Since LIST may be quite large, we want to minimize how often it |
| 1033 # appears in the expansion. Rather than use m4_car/m4_cdr iteration, |
| 1034 # we unbox the list, ignore the second argument, and use m4_shift2 to |
| 1035 # detect the end of recursion. The mismatch in () is intentional; see |
| 1036 # _m4_map. For m4_map, an empty list behaves like an empty sublist |
| 1037 # and gets ignored; for m4_mapall, we must special-case the empty |
| 1038 # list. |
| 1039 # |
| 1040 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1041 m4_define([m4_map], |
| 1042 [_m4_map([_m4_apply([$1]], [], $2)]) |
| 1043 |
| 1044 m4_define([m4_mapall], |
| 1045 [m4_if([$2], [], [], |
| 1046 [_m4_map([m4_apply([$1]], [], $2)])]) |
| 1047 |
| 1048 |
| 1049 # m4_map_sep(MACRO, SEPARATOR, LIST) |
| 1050 # m4_mapall_sep(MACRO, SEPARATOR, LIST) |
| 1051 # ------------------------------------- |
| 1052 # Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, |
| 1053 # $2... $N are the elements of LIST, and are in turn lists appropriate |
| 1054 # for m4_apply. SEPARATOR is expanded, in order to allow the creation |
| 1055 # of a list of arguments by using a single-quoted comma as the |
| 1056 # separator. For each empty sublist, m4_map_sep skips the expansion |
| 1057 # of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no |
| 1058 # arguments. |
| 1059 # |
| 1060 # For m4_mapall_sep, merely expand the first iteration without the |
| 1061 # separator, then include separator as part of subsequent recursion; |
| 1062 # but avoid extra expansion of LIST's side-effects via a helper macro. |
| 1063 # For m4_map_sep, things are trickier - we don't know if the first |
| 1064 # list element is an empty sublist, so we must define a self-modifying |
| 1065 # helper macro and use that as the separator instead. |
| 1066 m4_define([m4_map_sep], |
| 1067 [m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl |
| 1068 [_m4_map([_m4_apply([m4_Sep([$2])[]$1]], [], $3)m4_popdef([m4_Sep])]) |
| 1069 |
| 1070 m4_define([m4_mapall_sep], |
| 1071 [m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) |
| 1072 |
| 1073 m4_define([_m4_mapall_sep], |
| 1074 [m4_apply([$1], [$3])_m4_map([m4_apply([$2[]$1]], m4_shift2($@))]) |
| 1075 |
| 1076 # _m4_map(PREFIX, IGNORED, SUBLIST, ...) |
| 1077 # -------------------------------------- |
| 1078 # Common implementation for all four m4_map variants. The mismatch in |
| 1079 # the number of () is intentional. PREFIX must supply a form of |
| 1080 # m4_apply, the open `(', and the MACRO to be applied. Each iteration |
| 1081 # then appends `,', the current SUBLIST and the closing `)', then |
| 1082 # recurses to the next SUBLIST. IGNORED is an aid to ending recursion |
| 1083 # efficiently. |
| 1084 # |
| 1085 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1086 m4_define([_m4_map], |
| 1087 [m4_if([$#], [2], [], |
| 1088 [$1, [$3])$0([$1], m4_shift2($@))])]) |
| 1089 |
| 1090 # m4_transform(EXPRESSION, ARG...) |
| 1091 # -------------------------------- |
| 1092 # Expand EXPRESSION([ARG]) for each argument. More efficient than |
| 1093 # m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) |
| 1094 # |
| 1095 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1096 m4_define([m4_transform], |
| 1097 [m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], |
| 1098 [$#], [1], [], |
| 1099 [$#], [2], [$1([$2])[]], |
| 1100 [$1([$2])[]$0([$1], m4_shift2($@))])]) |
| 1101 |
| 1102 |
| 1103 # m4_transform_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) |
| 1104 # -------------------------------------------------------------- |
| 1105 # Perform a pairwise grouping of consecutive ARGs, by expanding |
| 1106 # EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the |
| 1107 # final argument is expanded with END-EXPR([ARGn]). |
| 1108 # |
| 1109 # For example: |
| 1110 # m4_define([show], [($*)m4_newline])dnl |
| 1111 # m4_transform_pair([show], [], [a], [b], [c], [d], [e])dnl |
| 1112 # => (a,b) |
| 1113 # => (c,d) |
| 1114 # => (e) |
| 1115 # |
| 1116 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1117 m4_define([m4_transform_pair], |
| 1118 [m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], |
| 1119 [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], |
| 1120 [$#], [2], [], |
| 1121 [$#], [3], [m4_default([$2], [$1])([$3])[]], |
| 1122 [$#], [4], [$1([$3], [$4])[]], |
| 1123 [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) |
| 1124 |
| 1125 |
| 1126 ## --------------------------- ## |
| 1127 ## 9. More diversion support. ## |
| 1128 ## --------------------------- ## |
| 1129 |
| 1130 |
| 1131 # _m4_divert(DIVERSION-NAME or NUMBER) |
| 1132 # ------------------------------------ |
| 1133 # If DIVERSION-NAME is the name of a diversion, return its number, |
| 1134 # otherwise if it is a NUMBER return it. |
| 1135 m4_define([_m4_divert], |
| 1136 [m4_ifdef([_m4_divert($1)], |
| 1137 [m4_indir([_m4_divert($1)])], |
| 1138 [$1])]) |
| 1139 |
| 1140 # KILL is only used to suppress output. |
| 1141 m4_define([_m4_divert(KILL)], -1) |
| 1142 |
| 1143 # The empty diversion name is a synonym for 0. |
| 1144 m4_define([_m4_divert()], 0) |
| 1145 |
| 1146 |
| 1147 # _m4_divert_n_stack |
| 1148 # ------------------ |
| 1149 # Print m4_divert_stack with newline prepended, if it's nonempty. |
| 1150 m4_define([_m4_divert_n_stack], |
| 1151 [m4_ifdef([m4_divert_stack], [ |
| 1152 _m4_defn([m4_divert_stack])])]) |
| 1153 |
| 1154 |
| 1155 # m4_divert(DIVERSION-NAME) |
| 1156 # ------------------------- |
| 1157 # Change the diversion stream to DIVERSION-NAME. |
| 1158 m4_define([m4_divert], |
| 1159 [m4_define([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)]dnl |
| 1160 [m4_builtin([divert], _m4_divert([$1]))]) |
| 1161 |
| 1162 |
| 1163 # m4_divert_push(DIVERSION-NAME) |
| 1164 # ------------------------------ |
| 1165 # Change the diversion stream to DIVERSION-NAME, while stacking old values. |
| 1166 m4_define([m4_divert_push], |
| 1167 [m4_pushdef([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)]dnl |
| 1168 [m4_pushdef([_m4_divert_diversion], [$1])]dnl |
| 1169 [m4_builtin([divert], _m4_divert([$1]))]) |
| 1170 |
| 1171 |
| 1172 # m4_divert_pop([DIVERSION-NAME]) |
| 1173 # ------------------------------- |
| 1174 # Change the diversion stream to its previous value, unstacking it. |
| 1175 # If specified, verify we left DIVERSION-NAME. |
| 1176 # When we pop the last value from the stack, we divert to -1. |
| 1177 m4_define([m4_divert_pop], |
| 1178 [m4_ifndef([_m4_divert_diversion], |
| 1179 [m4_fatal([too many m4_divert_pop])])]dnl |
| 1180 [m4_if([$1], [], [], |
| 1181 [$1], _m4_defn([_m4_divert_diversion]), [], |
| 1182 [m4_fatal([$0($1): diversion mismatch: ]_m4_divert_n_stack)])]dnl |
| 1183 [_m4_popdef([m4_divert_stack], [_m4_divert_diversion])]dnl |
| 1184 [m4_builtin([divert], |
| 1185 m4_ifdef([_m4_divert_diversion], |
| 1186 [_m4_divert(_m4_defn([_m4_divert_diversion]))], |
| 1187 -1))]) |
| 1188 |
| 1189 |
| 1190 # m4_divert_text(DIVERSION-NAME, CONTENT) |
| 1191 # --------------------------------------- |
| 1192 # Output CONTENT into DIVERSION-NAME (which may be a number actually). |
| 1193 # An end of line is appended for free to CONTENT. |
| 1194 m4_define([m4_divert_text], |
| 1195 [m4_divert_push([$1])$2 |
| 1196 m4_divert_pop([$1])]) |
| 1197 |
| 1198 |
| 1199 # m4_divert_once(DIVERSION-NAME, CONTENT) |
| 1200 # --------------------------------------- |
| 1201 # Output CONTENT into DIVERSION-NAME once, if not already there. |
| 1202 # An end of line is appended for free to CONTENT. |
| 1203 m4_define([m4_divert_once], |
| 1204 [m4_expand_once([m4_divert_text([$1], [$2])])]) |
| 1205 |
| 1206 |
| 1207 # m4_undivert(DIVERSION-NAME) |
| 1208 # --------------------------- |
| 1209 # Undivert DIVERSION-NAME. Unlike the M4 version, this only takes a single |
| 1210 # diversion identifier, and should not be used to undivert files. |
| 1211 m4_define([m4_undivert], |
| 1212 [m4_builtin([undivert], _m4_divert([$1]))]) |
| 1213 |
| 1214 |
| 1215 ## --------------------------------------------- ## |
| 1216 ## 10. Defining macros with bells and whistles. ## |
| 1217 ## --------------------------------------------- ## |
| 1218 |
| 1219 # `m4_defun' is basically `m4_define' but it equips the macro with the |
| 1220 # needed machinery for `m4_require'. A macro must be m4_defun'd if |
| 1221 # either it is m4_require'd, or it m4_require's. |
| 1222 # |
| 1223 # Two things deserve attention and are detailed below: |
| 1224 # 1. Implementation of m4_require |
| 1225 # 2. Keeping track of the expansion stack |
| 1226 # |
| 1227 # 1. Implementation of m4_require |
| 1228 # =============================== |
| 1229 # |
| 1230 # Of course m4_defun AC_PROVIDE's the macro, so that a macro which has |
| 1231 # been expanded is not expanded again when m4_require'd, but the |
| 1232 # difficult part is the proper expansion of macros when they are |
| 1233 # m4_require'd. |
| 1234 # |
| 1235 # The implementation is based on two ideas, (i) using diversions to |
| 1236 # prepare the expansion of the macro and its dependencies (by Franc,ois |
| 1237 # Pinard), and (ii) expand the most recently m4_require'd macros _after_ |
| 1238 # the previous macros (by Axel Thimm). |
| 1239 # |
| 1240 # |
| 1241 # The first idea: why use diversions? |
| 1242 # ----------------------------------- |
| 1243 # |
| 1244 # When a macro requires another, the other macro is expanded in new |
| 1245 # diversion, GROW. When the outer macro is fully expanded, we first |
| 1246 # undivert the most nested diversions (GROW - 1...), and finally |
| 1247 # undivert GROW. To understand why we need several diversions, |
| 1248 # consider the following example: |
| 1249 # |
| 1250 # | m4_defun([TEST1], [Test...REQUIRE([TEST2])1]) |
| 1251 # | m4_defun([TEST2], [Test...REQUIRE([TEST3])2]) |
| 1252 # | m4_defun([TEST3], [Test...3]) |
| 1253 # |
| 1254 # Because m4_require is not required to be first in the outer macros, we |
| 1255 # must keep the expansions of the various levels of m4_require separated. |
| 1256 # Right before executing the epilogue of TEST1, we have: |
| 1257 # |
| 1258 # GROW - 2: Test...3 |
| 1259 # GROW - 1: Test...2 |
| 1260 # GROW: Test...1 |
| 1261 # BODY: |
| 1262 # |
| 1263 # Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and |
| 1264 # GROW into the regular flow, BODY. |
| 1265 # |
| 1266 # GROW - 2: |
| 1267 # GROW - 1: |
| 1268 # GROW: |
| 1269 # BODY: Test...3; Test...2; Test...1 |
| 1270 # |
| 1271 # (The semicolons are here for clarification, but of course are not |
| 1272 # emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) |
| 1273 # implement. |
| 1274 # |
| 1275 # |
| 1276 # The second idea: first required first out |
| 1277 # ----------------------------------------- |
| 1278 # |
| 1279 # The natural implementation of the idea above is buggy and produces |
| 1280 # very surprising results in some situations. Let's consider the |
| 1281 # following example to explain the bug: |
| 1282 # |
| 1283 # | m4_defun([TEST1], [REQUIRE([TEST2a])REQUIRE([TEST2b])]) |
| 1284 # | m4_defun([TEST2a], []) |
| 1285 # | m4_defun([TEST2b], [REQUIRE([TEST3])]) |
| 1286 # | m4_defun([TEST3], [REQUIRE([TEST2a])]) |
| 1287 # | |
| 1288 # | AC_INIT |
| 1289 # | TEST1 |
| 1290 # |
| 1291 # The dependencies between the macros are: |
| 1292 # |
| 1293 # 3 --- 2b |
| 1294 # / \ is m4_require'd by |
| 1295 # / \ left -------------------- right |
| 1296 # 2a ------------ 1 |
| 1297 # |
| 1298 # If you strictly apply the rules given in the previous section you get: |
| 1299 # |
| 1300 # GROW - 2: TEST3 |
| 1301 # GROW - 1: TEST2a; TEST2b |
| 1302 # GROW: TEST1 |
| 1303 # BODY: |
| 1304 # |
| 1305 # (TEST2a, although required by TEST3 is not expanded in GROW - 3 |
| 1306 # because is has already been expanded before in GROW - 1, so it has |
| 1307 # been AC_PROVIDE'd, so it is not expanded again) so when you undivert |
| 1308 # the stack of diversions, you get: |
| 1309 # |
| 1310 # GROW - 2: |
| 1311 # GROW - 1: |
| 1312 # GROW: |
| 1313 # BODY: TEST3; TEST2a; TEST2b; TEST1 |
| 1314 # |
| 1315 # i.e., TEST2a is expanded after TEST3 although the latter required the |
| 1316 # former. |
| 1317 # |
| 1318 # Starting from 2.50, we use an implementation provided by Axel Thimm. |
| 1319 # The idea is simple: the order in which macros are emitted must be the |
| 1320 # same as the one in which macros are expanded. (The bug above can |
| 1321 # indeed be described as: a macro has been AC_PROVIDE'd before its |
| 1322 # dependent, but it is emitted after: the lack of correlation between |
| 1323 # emission and expansion order is guilty). |
| 1324 # |
| 1325 # How to do that? You keep the stack of diversions to elaborate the |
| 1326 # macros, but each time a macro is fully expanded, emit it immediately. |
| 1327 # |
| 1328 # In the example above, when TEST2a is expanded, but it's epilogue is |
| 1329 # not run yet, you have: |
| 1330 # |
| 1331 # GROW - 2: |
| 1332 # GROW - 1: TEST2a |
| 1333 # GROW: Elaboration of TEST1 |
| 1334 # BODY: |
| 1335 # |
| 1336 # The epilogue of TEST2a emits it immediately: |
| 1337 # |
| 1338 # GROW - 2: |
| 1339 # GROW - 1: |
| 1340 # GROW: Elaboration of TEST1 |
| 1341 # BODY: TEST2a |
| 1342 # |
| 1343 # TEST2b then requires TEST3, so right before the epilogue of TEST3, you |
| 1344 # have: |
| 1345 # |
| 1346 # GROW - 2: TEST3 |
| 1347 # GROW - 1: Elaboration of TEST2b |
| 1348 # GROW: Elaboration of TEST1 |
| 1349 # BODY: TEST2a |
| 1350 # |
| 1351 # The epilogue of TEST3 emits it: |
| 1352 # |
| 1353 # GROW - 2: |
| 1354 # GROW - 1: Elaboration of TEST2b |
| 1355 # GROW: Elaboration of TEST1 |
| 1356 # BODY: TEST2a; TEST3 |
| 1357 # |
| 1358 # TEST2b is now completely expanded, and emitted: |
| 1359 # |
| 1360 # GROW - 2: |
| 1361 # GROW - 1: |
| 1362 # GROW: Elaboration of TEST1 |
| 1363 # BODY: TEST2a; TEST3; TEST2b |
| 1364 # |
| 1365 # and finally, TEST1 is finished and emitted: |
| 1366 # |
| 1367 # GROW - 2: |
| 1368 # GROW - 1: |
| 1369 # GROW: |
| 1370 # BODY: TEST2a; TEST3; TEST2b: TEST1 |
| 1371 # |
| 1372 # The idea is simple, but the implementation is a bit evolved. If you |
| 1373 # are like me, you will want to see the actual functioning of this |
| 1374 # implementation to be convinced. The next section gives the full |
| 1375 # details. |
| 1376 # |
| 1377 # |
| 1378 # The Axel Thimm implementation at work |
| 1379 # ------------------------------------- |
| 1380 # |
| 1381 # We consider the macros above, and this configure.ac: |
| 1382 # |
| 1383 # AC_INIT |
| 1384 # TEST1 |
| 1385 # |
| 1386 # You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and |
| 1387 # m4_require at hand to follow the steps. |
| 1388 # |
| 1389 # This implements tries not to assume that the current diversion is |
| 1390 # BODY, so as soon as a macro (m4_defun'd) is expanded, we first |
| 1391 # record the current diversion under the name _m4_divert_dump (denoted |
| 1392 # DUMP below for short). This introduces an important difference with |
| 1393 # the previous versions of Autoconf: you cannot use m4_require if you |
| 1394 # are not inside an m4_defun'd macro, and especially, you cannot |
| 1395 # m4_require directly from the top level. |
| 1396 # |
| 1397 # We have not tried to simulate the old behavior (better yet, we |
| 1398 # diagnose it), because it is too dangerous: a macro m4_require'd from |
| 1399 # the top level is expanded before the body of `configure', i.e., before |
| 1400 # any other test was run. I let you imagine the result of requiring |
| 1401 # AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... |
| 1402 # |
| 1403 # After AC_INIT was run, the current diversion is BODY. |
| 1404 # * AC_INIT was run |
| 1405 # DUMP: undefined |
| 1406 # diversion stack: BODY |- |
| 1407 # |
| 1408 # * TEST1 is expanded |
| 1409 # The prologue of TEST1 sets _m4_divert_dump, which is the diversion |
| 1410 # where the current elaboration will be dumped, to the current |
| 1411 # diversion. It also m4_divert_push to GROW, where the full |
| 1412 # expansion of TEST1 and its dependencies will be elaborated. |
| 1413 # DUMP: BODY |
| 1414 # BODY: empty |
| 1415 # diversions: GROW, BODY |- |
| 1416 # |
| 1417 # * TEST1 requires TEST2a |
| 1418 # _m4_require_call m4_divert_pushes another temporary diversion, |
| 1419 # GROW - 1, and expands TEST2a in there. |
| 1420 # DUMP: BODY |
| 1421 # BODY: empty |
| 1422 # GROW - 1: TEST2a |
| 1423 # diversions: GROW - 1, GROW, BODY |- |
| 1424 # Than the content of the temporary diversion is moved to DUMP and the |
| 1425 # temporary diversion is popped. |
| 1426 # DUMP: BODY |
| 1427 # BODY: TEST2a |
| 1428 # diversions: GROW, BODY |- |
| 1429 # |
| 1430 # * TEST1 requires TEST2b |
| 1431 # Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. |
| 1432 # DUMP: BODY |
| 1433 # BODY: TEST2a |
| 1434 # diversions: GROW - 1, GROW, BODY |- |
| 1435 # |
| 1436 # * TEST2b requires TEST3 |
| 1437 # _m4_require_call pushes GROW - 2 and expands TEST3 here. |
| 1438 # (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so |
| 1439 # nothing happens.) |
| 1440 # DUMP: BODY |
| 1441 # BODY: TEST2a |
| 1442 # GROW - 2: TEST3 |
| 1443 # diversions: GROW - 2, GROW - 1, GROW, BODY |- |
| 1444 # Than the diversion is appended to DUMP, and popped. |
| 1445 # DUMP: BODY |
| 1446 # BODY: TEST2a; TEST3 |
| 1447 # diversions: GROW - 1, GROW, BODY |- |
| 1448 # |
| 1449 # * TEST1 requires TEST2b (contd.) |
| 1450 # The content of TEST2b is expanded... |
| 1451 # DUMP: BODY |
| 1452 # BODY: TEST2a; TEST3 |
| 1453 # GROW - 1: TEST2b, |
| 1454 # diversions: GROW - 1, GROW, BODY |- |
| 1455 # ... and moved to DUMP. |
| 1456 # DUMP: BODY |
| 1457 # BODY: TEST2a; TEST3; TEST2b |
| 1458 # diversions: GROW, BODY |- |
| 1459 # |
| 1460 # * TEST1 is expanded: epilogue |
| 1461 # TEST1's own content is in GROW... |
| 1462 # DUMP: BODY |
| 1463 # BODY: TEST2a; TEST3; TEST2b |
| 1464 # GROW: TEST1 |
| 1465 # diversions: BODY |- |
| 1466 # ... and it's epilogue moves it to DUMP and then undefines DUMP. |
| 1467 # DUMP: undefined |
| 1468 # BODY: TEST2a; TEST3; TEST2b; TEST1 |
| 1469 # diversions: BODY |- |
| 1470 # |
| 1471 # |
| 1472 # 2. Keeping track of the expansion stack |
| 1473 # ======================================= |
| 1474 # |
| 1475 # When M4 expansion goes wrong it is often extremely hard to find the |
| 1476 # path amongst macros that drove to the failure. What is needed is |
| 1477 # the stack of macro `calls'. One could imagine that GNU M4 would |
| 1478 # maintain a stack of macro expansions, unfortunately it doesn't, so |
| 1479 # we do it by hand. This is of course extremely costly, but the help |
| 1480 # this stack provides is worth it. Nevertheless to limit the |
| 1481 # performance penalty this is implemented only for m4_defun'd macros, |
| 1482 # not for define'd macros. |
| 1483 # |
| 1484 # The scheme is simplistic: each time we enter an m4_defun'd macros, |
| 1485 # we prepend its name in m4_expansion_stack, and when we exit the |
| 1486 # macro, we remove it (thanks to pushdef/popdef). |
| 1487 # |
| 1488 # In addition, we want to detect circular m4_require dependencies. |
| 1489 # Each time we expand a macro FOO we define _m4_expanding(FOO); and |
| 1490 # m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. |
| 1491 |
| 1492 |
| 1493 # m4_expansion_stack_push(TEXT) |
| 1494 # ----------------------------- |
| 1495 m4_define([m4_expansion_stack_push], |
| 1496 [m4_pushdef([m4_expansion_stack], |
| 1497 [$1]m4_ifdef([m4_expansion_stack], [ |
| 1498 _m4_defn([m4_expansion_stack])]))]) |
| 1499 |
| 1500 |
| 1501 # m4_expansion_stack_pop |
| 1502 # ---------------------- |
| 1503 m4_define([m4_expansion_stack_pop], |
| 1504 [m4_popdef([m4_expansion_stack])]) |
| 1505 |
| 1506 |
| 1507 # m4_expansion_stack_dump |
| 1508 # ----------------------- |
| 1509 # Dump the expansion stack. |
| 1510 m4_define([m4_expansion_stack_dump], |
| 1511 [m4_ifdef([m4_expansion_stack], |
| 1512 [m4_errprintn(_m4_defn([m4_expansion_stack]))])dnl |
| 1513 m4_errprintn(m4_location[: the top level])]) |
| 1514 |
| 1515 |
| 1516 # _m4_divert(GROW) |
| 1517 # ---------------- |
| 1518 # This diversion is used by the m4_defun/m4_require machinery. It is |
| 1519 # important to keep room before GROW because for each nested |
| 1520 # AC_REQUIRE we use an additional diversion (i.e., two m4_require's |
| 1521 # will use GROW - 2. More than 3 levels has never seemed to be |
| 1522 # needed.) |
| 1523 # |
| 1524 # ... |
| 1525 # - GROW - 2 |
| 1526 # m4_require'd code, 2 level deep |
| 1527 # - GROW - 1 |
| 1528 # m4_require'd code, 1 level deep |
| 1529 # - GROW |
| 1530 # m4_defun'd macros are elaborated here. |
| 1531 |
| 1532 m4_define([_m4_divert(GROW)], 10000) |
| 1533 |
| 1534 |
| 1535 # _m4_defun_pro(MACRO-NAME) |
| 1536 # ------------------------- |
| 1537 # The prologue for Autoconf macros. |
| 1538 # |
| 1539 # This is called frequently, so minimize the number of macro invocations |
| 1540 # by avoiding dnl and m4_defn overhead. |
| 1541 m4_define([_m4_defun_pro], |
| 1542 m4_do([[m4_ifdef([m4_expansion_stack], [], [_m4_defun_pro_outer[]])]], |
| 1543 [[m4_expansion_stack_push(_m4_defn( |
| 1544 [m4_location($1)])[: $1 is expanded from...])]], |
| 1545 [[m4_pushdef([_m4_expanding($1)])]])) |
| 1546 |
| 1547 m4_define([_m4_defun_pro_outer], |
| 1548 [m4_copy([_m4_divert_diversion], [_m4_divert_dump])m4_divert_push([GROW])]) |
| 1549 |
| 1550 # _m4_defun_epi(MACRO-NAME) |
| 1551 # ------------------------- |
| 1552 # The Epilogue for Autoconf macros. MACRO-NAME only helps tracing |
| 1553 # the PRO/EPI pairs. |
| 1554 # |
| 1555 # This is called frequently, so minimize the number of macro invocations |
| 1556 # by avoiding dnl and m4_popdef overhead. |
| 1557 m4_define([_m4_defun_epi], |
| 1558 m4_do([[_m4_popdef([_m4_expanding($1)])]], |
| 1559 [[m4_expansion_stack_pop()]], |
| 1560 [[m4_ifdef([m4_expansion_stack], [], [_m4_defun_epi_outer[]])]], |
| 1561 [[m4_provide([$1])]])) |
| 1562 |
| 1563 m4_define([_m4_defun_epi_outer], |
| 1564 [_m4_undefine([_m4_divert_dump])m4_divert_pop([GROW])m4_undivert([GROW])]) |
| 1565 |
| 1566 |
| 1567 # m4_defun(NAME, EXPANSION) |
| 1568 # ------------------------- |
| 1569 # Define a macro which automatically provides itself. Add machinery |
| 1570 # so the macro automatically switches expansion to the diversion |
| 1571 # stack if it is not already using it. In this case, once finished, |
| 1572 # it will bring back all the code accumulated in the diversion stack. |
| 1573 # This, combined with m4_require, achieves the topological ordering of |
| 1574 # macros. We don't use this macro to define some frequently called |
| 1575 # macros that are not involved in ordering constraints, to save m4 |
| 1576 # processing. |
| 1577 m4_define([m4_defun], |
| 1578 [m4_define([m4_location($1)], m4_location)dnl |
| 1579 m4_define([$1], |
| 1580 [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])]) |
| 1581 |
| 1582 |
| 1583 # m4_defun_once(NAME, EXPANSION) |
| 1584 # ------------------------------ |
| 1585 # As m4_defun, but issues the EXPANSION only once, and warns if used |
| 1586 # several times. |
| 1587 m4_define([m4_defun_once], |
| 1588 [m4_define([m4_location($1)], m4_location)dnl |
| 1589 m4_define([$1], |
| 1590 [m4_provide_if([$1], |
| 1591 [m4_warn([syntax], [$1 invoked multiple times])], |
| 1592 [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])])]) |
| 1593 |
| 1594 |
| 1595 # m4_pattern_forbid(ERE, [WHY]) |
| 1596 # ----------------------------- |
| 1597 # Declare that no token matching the forbidden extended regular |
| 1598 # expression ERE should be seen in the output unless... |
| 1599 m4_define([m4_pattern_forbid], []) |
| 1600 |
| 1601 |
| 1602 # m4_pattern_allow(ERE) |
| 1603 # --------------------- |
| 1604 # ... that token also matches the allowed extended regular expression ERE. |
| 1605 # Both used via traces. |
| 1606 m4_define([m4_pattern_allow], []) |
| 1607 |
| 1608 |
| 1609 ## --------------------------------- ## |
| 1610 ## 11. Dependencies between macros. ## |
| 1611 ## --------------------------------- ## |
| 1612 |
| 1613 |
| 1614 # m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) |
| 1615 # --------------------------------------------- |
| 1616 # Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. |
| 1617 m4_define([m4_before], |
| 1618 [m4_provide_if([$2], |
| 1619 [m4_warn([syntax], [$2 was called before $1])])]) |
| 1620 |
| 1621 |
| 1622 # m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) |
| 1623 # ----------------------------------------------------------- |
| 1624 # If NAME-TO-CHECK has never been expanded (actually, if it is not |
| 1625 # m4_provide'd), expand BODY-TO-EXPAND *before* the current macro |
| 1626 # expansion. Once expanded, emit it in _m4_divert_dump. Keep track |
| 1627 # of the m4_require chain in m4_expansion_stack. |
| 1628 # |
| 1629 # The normal cases are: |
| 1630 # |
| 1631 # - NAME-TO-CHECK == BODY-TO-EXPAND |
| 1632 # Which you can use for regular macros with or without arguments, e.g., |
| 1633 # m4_require([AC_PROG_CC], [AC_PROG_CC]) |
| 1634 # m4_require([AC_CHECK_HEADERS(limits.h)], [AC_CHECK_HEADERS(limits.h)]) |
| 1635 # which is just the same as |
| 1636 # m4_require([AC_PROG_CC]) |
| 1637 # m4_require([AC_CHECK_HEADERS(limits.h)]) |
| 1638 # |
| 1639 # - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) |
| 1640 # In the case of macros with irregular names. For instance: |
| 1641 # m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) |
| 1642 # which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are |
| 1643 # part of the name, it is not an argument) has not been run, then |
| 1644 # call it.' |
| 1645 # Had you used |
| 1646 # m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) |
| 1647 # then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., |
| 1648 # call the macro `AC_LANG_COMPILER' with `C' as argument. |
| 1649 # |
| 1650 # You could argue that `AC_LANG_COMPILER', when it receives an argument |
| 1651 # such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this |
| 1652 # `extension' prevents `AC_LANG_COMPILER' from having actual arguments that |
| 1653 # it passes to `AC_LANG_COMPILER(C)'. |
| 1654 # |
| 1655 # This is called frequently, so minimize the number of macro invocations |
| 1656 # by avoiding dnl and other overhead on the common path. |
| 1657 m4_define([m4_require], |
| 1658 m4_do([[m4_ifdef([_m4_expanding($1)], |
| 1659 [m4_fatal([$0: circular dependency of $1])])]], |
| 1660 [[m4_ifdef([_m4_divert_dump], [], |
| 1661 [m4_fatal([$0($1): cannot be used outside of an ]dnl |
| 1662 m4_bmatch([$0], [^AC_], [[AC_DEFUN]], [[m4_defun]])['d macro])])]], |
| 1663 [[m4_provide_if([$1], |
| 1664 [], |
| 1665 [_m4_require_call([$1], [$2])])]])) |
| 1666 |
| 1667 |
| 1668 # _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) |
| 1669 # ----------------------------------------------------------------- |
| 1670 # If m4_require decides to expand the body, it calls this macro. |
| 1671 # |
| 1672 # This is called frequently, so minimize the number of macro invocations |
| 1673 # by avoiding dnl and other overhead on the common path. |
| 1674 m4_define([_m4_require_call], |
| 1675 m4_do([[m4_define([_m4_divert_grow], m4_decr(_m4_divert_grow))]], |
| 1676 [[m4_divert_push(_m4_divert_grow)]], |
| 1677 [[m4_default([$2], [$1]) |
| 1678 m4_provide_if([$1], |
| 1679 [], |
| 1680 [m4_warn([syntax], |
| 1681 [$1 is m4_require'd but not m4_defun'd])])]], |
| 1682 [[m4_divert(_m4_defn([_m4_divert_dump]))]], |
| 1683 [[m4_undivert(_m4_divert_grow)]], |
| 1684 [[m4_divert_pop(_m4_divert_grow)]], |
| 1685 [[m4_define([_m4_divert_grow], m4_incr(_m4_divert_grow))]])) |
| 1686 |
| 1687 |
| 1688 # _m4_divert_grow |
| 1689 # --------------- |
| 1690 # The counter for _m4_require_call. |
| 1691 m4_define([_m4_divert_grow], _m4_divert([GROW])) |
| 1692 |
| 1693 |
| 1694 # m4_expand_once(TEXT, [WITNESS = TEXT]) |
| 1695 # -------------------------------------- |
| 1696 # If TEXT has never been expanded, expand it *here*. Use WITNESS as |
| 1697 # as a memory that TEXT has already been expanded. |
| 1698 m4_define([m4_expand_once], |
| 1699 [m4_provide_if(m4_ifval([$2], [[$2]], [[$1]]), |
| 1700 [], |
| 1701 [m4_provide(m4_ifval([$2], [[$2]], [[$1]]))[]$1])]) |
| 1702 |
| 1703 |
| 1704 # m4_provide(MACRO-NAME) |
| 1705 # ---------------------- |
| 1706 m4_define([m4_provide], |
| 1707 [m4_define([m4_provide($1)])]) |
| 1708 |
| 1709 |
| 1710 # m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) |
| 1711 # ------------------------------------------------------- |
| 1712 # If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. |
| 1713 # The purpose of this macro is to provide the user with a means to |
| 1714 # check macros which are provided without letting her know how the |
| 1715 # information is coded. |
| 1716 m4_define([m4_provide_if], |
| 1717 [m4_ifdef([m4_provide($1)], |
| 1718 [$2], [$3])]) |
| 1719 |
| 1720 |
| 1721 ## --------------------- ## |
| 1722 ## 12. Text processing. ## |
| 1723 ## --------------------- ## |
| 1724 |
| 1725 |
| 1726 # m4_cr_letters |
| 1727 # m4_cr_LETTERS |
| 1728 # m4_cr_Letters |
| 1729 # ------------- |
| 1730 m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) |
| 1731 m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) |
| 1732 m4_define([m4_cr_Letters], |
| 1733 m4_defn([m4_cr_letters])dnl |
| 1734 m4_defn([m4_cr_LETTERS])dnl |
| 1735 ) |
| 1736 |
| 1737 |
| 1738 # m4_cr_digits |
| 1739 # ------------ |
| 1740 m4_define([m4_cr_digits], [0123456789]) |
| 1741 |
| 1742 |
| 1743 # m4_cr_alnum |
| 1744 # ----------- |
| 1745 m4_define([m4_cr_alnum], |
| 1746 m4_defn([m4_cr_Letters])dnl |
| 1747 m4_defn([m4_cr_digits])dnl |
| 1748 ) |
| 1749 |
| 1750 |
| 1751 # m4_cr_symbols1 |
| 1752 # m4_cr_symbols2 |
| 1753 # ------------------------------- |
| 1754 m4_define([m4_cr_symbols1], |
| 1755 m4_defn([m4_cr_Letters])dnl |
| 1756 _) |
| 1757 |
| 1758 m4_define([m4_cr_symbols2], |
| 1759 m4_defn([m4_cr_symbols1])dnl |
| 1760 m4_defn([m4_cr_digits])dnl |
| 1761 ) |
| 1762 |
| 1763 # m4_cr_all |
| 1764 # --------- |
| 1765 # The character range representing everything, with `-' as the last |
| 1766 # character, since it is special to m4_translit. Use with care, because |
| 1767 # it contains characters special to M4 (fortunately, both ASCII and EBCDIC |
| 1768 # have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It |
| 1769 # also contains characters special to terminals, so it should never be |
| 1770 # displayed in an error message. Also, attempts to map [ and ] to other |
| 1771 # characters via m4_translit must deal with the fact that m4_translit does |
| 1772 # not add quotes to the output. |
| 1773 # |
| 1774 # It is mainly useful in generating inverted character range maps, for use |
| 1775 # in places where m4_translit is faster than an equivalent m4_bpatsubst; |
| 1776 # the regex `[^a-z]' is equivalent to: |
| 1777 # m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) |
| 1778 m4_define([m4_cr_all], |
| 1779 m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( |
| 1780 ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [-])-) |
| 1781 |
| 1782 |
| 1783 # _m4_define_cr_not(CATEGORY) |
| 1784 # --------------------------- |
| 1785 # Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. |
| 1786 m4_define([_m4_define_cr_not], |
| 1787 [m4_define([m4_cr_not_$1], |
| 1788 m4_translit(m4_dquote(m4_defn([m4_cr_all])), |
| 1789 m4_defn([m4_cr_$1])))]) |
| 1790 |
| 1791 |
| 1792 # m4_cr_not_letters |
| 1793 # m4_cr_not_LETTERS |
| 1794 # m4_cr_not_Letters |
| 1795 # m4_cr_not_digits |
| 1796 # m4_cr_not_alnum |
| 1797 # m4_cr_not_symbols1 |
| 1798 # m4_cr_not_symbols2 |
| 1799 # ------------------ |
| 1800 # Inverse character sets |
| 1801 _m4_define_cr_not([letters]) |
| 1802 _m4_define_cr_not([LETTERS]) |
| 1803 _m4_define_cr_not([Letters]) |
| 1804 _m4_define_cr_not([digits]) |
| 1805 _m4_define_cr_not([alnum]) |
| 1806 _m4_define_cr_not([symbols1]) |
| 1807 _m4_define_cr_not([symbols2]) |
| 1808 |
| 1809 |
| 1810 # m4_newline |
| 1811 # ---------- |
| 1812 # Expands to a newline. Exists for formatting reasons. |
| 1813 m4_define([m4_newline], [ |
| 1814 ]) |
| 1815 |
| 1816 |
| 1817 # m4_re_escape(STRING) |
| 1818 # -------------------- |
| 1819 # Escape RE active characters in STRING. |
| 1820 m4_define([m4_re_escape], |
| 1821 [m4_bpatsubst([$1], |
| 1822 [[][*+.?\^$]], [\\\&])]) |
| 1823 |
| 1824 |
| 1825 # m4_re_string |
| 1826 # ------------ |
| 1827 # Regexp for `[a-zA-Z_0-9]*' |
| 1828 # m4_dquote provides literal [] for the character class. |
| 1829 m4_define([m4_re_string], |
| 1830 m4_dquote(m4_defn([m4_cr_symbols2]))dnl |
| 1831 [*]dnl |
| 1832 ) |
| 1833 |
| 1834 |
| 1835 # m4_re_word |
| 1836 # ---------- |
| 1837 # Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' |
| 1838 m4_define([m4_re_word], |
| 1839 m4_dquote(m4_defn([m4_cr_symbols1]))dnl |
| 1840 m4_defn([m4_re_string])dnl |
| 1841 ) |
| 1842 |
| 1843 |
| 1844 # m4_tolower(STRING) |
| 1845 # m4_toupper(STRING) |
| 1846 # ------------------ |
| 1847 # These macros convert STRING to lowercase or uppercase. |
| 1848 # |
| 1849 # Rather than expand the m4_defn each time, we inline them up front. |
| 1850 m4_define([m4_tolower], |
| 1851 [m4_translit([$1], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, |
| 1852 ]m4_dquote(m4_defn([m4_cr_letters]))[)]) |
| 1853 m4_define([m4_toupper], |
| 1854 [m4_translit([$1], ]m4_dquote(m4_defn([m4_cr_letters]))[, |
| 1855 ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) |
| 1856 |
| 1857 |
| 1858 # m4_split(STRING, [REGEXP]) |
| 1859 # -------------------------- |
| 1860 # |
| 1861 # Split STRING into an m4 list of quoted elements. The elements are |
| 1862 # quoted with [ and ]. Beginning spaces and end spaces *are kept*. |
| 1863 # Use m4_strip to remove them. |
| 1864 # |
| 1865 # REGEXP specifies where to split. Default is [\t ]+. |
| 1866 # |
| 1867 # If STRING is empty, the result is an empty list. |
| 1868 # |
| 1869 # Pay attention to the m4_changequotes. When m4 reads the definition of |
| 1870 # m4_split, it still has quotes set to [ and ]. Luckily, these are matched |
| 1871 # in the macro body, so the definition is stored correctly. Use the same |
| 1872 # alternate quotes as m4_noquote; it must be unlikely to appear in $1. |
| 1873 # |
| 1874 # Also, notice that $1 is quoted twice, since we want the result to |
| 1875 # be quoted. Then you should understand that the argument of |
| 1876 # patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). |
| 1877 # |
| 1878 # This macro is safe on active symbols, i.e.: |
| 1879 # m4_define(active, ACTIVE) |
| 1880 # m4_split([active active ])end |
| 1881 # => [active], [active], []end |
| 1882 # |
| 1883 # Optimize on regex of ` ' (space), since m4_foreach_w already guarantees |
| 1884 # that the list contains single space separators, and a common case is |
| 1885 # splitting a single-element list. This macro is called frequently, |
| 1886 # so avoid unnecessary dnl inside the definition. |
| 1887 m4_define([m4_split], |
| 1888 [m4_if([$1], [], [], |
| 1889 [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], [_$0($@)])], |
| 1890 [$2], [], [_$0([$1], [[ ]+])], |
| 1891 [_$0($@)])]) |
| 1892 |
| 1893 m4_define([_m4_split], |
| 1894 [m4_changequote([-=<{(],[)}>=-])]dnl |
| 1895 [[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, |
| 1896 -=<{(], [)}>=-)]m4_changequote([, ])]) |
| 1897 |
| 1898 |
| 1899 |
| 1900 # m4_flatten(STRING) |
| 1901 # ------------------ |
| 1902 # If STRING contains end of lines, replace them with spaces. If there |
| 1903 # are backslashed end of lines, remove them. This macro is safe with |
| 1904 # active symbols. |
| 1905 # m4_define(active, ACTIVE) |
| 1906 # m4_flatten([active |
| 1907 # act\ |
| 1908 # ive])end |
| 1909 # => active activeend |
| 1910 # |
| 1911 # In m4, m4_bpatsubst is expensive, so first check for a newline. |
| 1912 m4_define([m4_flatten], |
| 1913 [m4_if(m4_index([$1], [ |
| 1914 ]), [-1], [[$1]], |
| 1915 [m4_translit(m4_bpatsubst([[[$1]]], [\\ |
| 1916 ]), [ |
| 1917 ], [ ])])]) |
| 1918 |
| 1919 |
| 1920 # m4_strip(STRING) |
| 1921 # ---------------- |
| 1922 # Expands into STRING with tabs and spaces singled out into a single |
| 1923 # space, and removing leading and trailing spaces. |
| 1924 # |
| 1925 # This macro is robust to active symbols. |
| 1926 # m4_define(active, ACTIVE) |
| 1927 # m4_strip([ active <tab> <tab>active ])end |
| 1928 # => active activeend |
| 1929 # |
| 1930 # First, notice that we guarantee trailing space. Why? Because regular |
| 1931 # expressions are greedy, and `.* ?' would always group the space into the |
| 1932 # .* portion. The algorithm is simpler by avoiding `?' at the end. The |
| 1933 # algorithm correctly strips everything if STRING is just ` '. |
| 1934 # |
| 1935 # Then notice the second pattern: it is in charge of removing the |
| 1936 # leading/trailing spaces. Why not just `[^ ]'? Because they are |
| 1937 # applied to over-quoted strings, i.e. more or less [STRING], due |
| 1938 # to the limitations of m4_bpatsubsts. So the leading space in STRING |
| 1939 # is the *second* character; equally for the trailing space. |
| 1940 m4_define([m4_strip], |
| 1941 [m4_bpatsubsts([$1 ], |
| 1942 [[ ]+], [ ], |
| 1943 [^. ?\(.*\) .$], [[[\1]]])]) |
| 1944 |
| 1945 |
| 1946 # m4_normalize(STRING) |
| 1947 # -------------------- |
| 1948 # Apply m4_flatten and m4_strip to STRING. |
| 1949 # |
| 1950 # The argument is quoted, so that the macro is robust to active symbols: |
| 1951 # |
| 1952 # m4_define(active, ACTIVE) |
| 1953 # m4_normalize([ act\ |
| 1954 # ive |
| 1955 # active ])end |
| 1956 # => active activeend |
| 1957 |
| 1958 m4_define([m4_normalize], |
| 1959 [m4_strip(m4_flatten([$1]))]) |
| 1960 |
| 1961 |
| 1962 |
| 1963 # m4_join(SEP, ARG1, ARG2...) |
| 1964 # --------------------------- |
| 1965 # Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG |
| 1966 # is the empty string. No expansion is performed on SEP or ARGs. |
| 1967 # |
| 1968 # Since the number of arguments to join can be arbitrarily long, we |
| 1969 # want to avoid having more than one $@ in the macro definition; |
| 1970 # otherwise, the expansion would require twice the memory of the already |
| 1971 # long list. Hence, m4_join merely looks for the first non-empty element, |
| 1972 # and outputs just that element; while _m4_join looks for all non-empty |
| 1973 # elements, and outputs them following a separator. The final trick to |
| 1974 # note is that we decide between recursing with $0 or _$0 based on the |
| 1975 # nested m4_if ending with `_'. |
| 1976 # |
| 1977 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1978 m4_define([m4_join], |
| 1979 [m4_if([$#], [1], [], |
| 1980 [$#], [2], [[$2]], |
| 1981 [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) |
| 1982 m4_define([_m4_join], |
| 1983 [m4_if([$#$2], [2], [], |
| 1984 [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) |
| 1985 |
| 1986 # m4_joinall(SEP, ARG1, ARG2...) |
| 1987 # ------------------------------ |
| 1988 # Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. |
| 1989 # No expansion is performed on SEP or ARGs. |
| 1990 # |
| 1991 # Please keep foreach.m4 in sync with any adjustments made here. |
| 1992 m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) |
| 1993 m4_define([_m4_joinall], |
| 1994 [m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) |
| 1995 |
| 1996 # m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) |
| 1997 # -------------------------------------------------------- |
| 1998 # Produce the pairwise combination of every element in the quoted, |
| 1999 # comma-separated PREFIX-LIST with every element from the SUFFIX arguments. |
| 2000 # Each pair is joined with INFIX, and pairs are separated by SEPARATOR. |
| 2001 # No expansion occurs on SEPARATOR, INFIX, or elements of either list. |
| 2002 # |
| 2003 # For example: |
| 2004 # m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) |
| 2005 # => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 |
| 2006 # |
| 2007 # In order to have the correct number of SEPARATORs, we use a temporary |
| 2008 # variable that redefines itself after the first use. We must use defn |
| 2009 # rather than overquoting in case PREFIX or SUFFIX contains $1, but use |
| 2010 # _m4_defn for speed. Likewise, we compute the m4_shift3 only once, |
| 2011 # rather than in each iteration of the outer m4_foreach. |
| 2012 m4_define([m4_combine], |
| 2013 [m4_if(m4_eval([$# > 3]), [1], |
| 2014 [m4_pushdef([m4_Separator], [m4_define([m4_Separator], |
| 2015 _m4_defn([m4_echo]))])]]dnl |
| 2016 [[m4_foreach([m4_Prefix], [$2], |
| 2017 [m4_foreach([m4_Suffix], ]m4_dquote(m4_dquote(m4_shift3($@)))[, |
| 2018 [m4_Separator([$1])[]_m4_defn([m4_Prefix])[$3]_m4_defn( |
| 2019 [m4_Suffix])])])]]dnl |
| 2020 [[_m4_popdef([m4_Separator])])]) |
| 2021 |
| 2022 |
| 2023 # m4_append(MACRO-NAME, STRING, [SEPARATOR]) |
| 2024 # ------------------------------------------ |
| 2025 # Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' |
| 2026 # at the end. It is valid to use this macro with MACRO-NAME undefined, |
| 2027 # in which case no SEPARATOR is added. Be aware that the criterion is |
| 2028 # `not being defined', and not `not being empty'. |
| 2029 # |
| 2030 # Note that neither STRING nor SEPARATOR are expanded here; rather, when |
| 2031 # you expand MACRO-NAME, they will be expanded at that point in time. |
| 2032 # |
| 2033 # This macro is robust to active symbols. It can be used to grow |
| 2034 # strings. |
| 2035 # |
| 2036 # | m4_define(active, ACTIVE)dnl |
| 2037 # | m4_append([sentence], [This is an])dnl |
| 2038 # | m4_append([sentence], [ active ])dnl |
| 2039 # | m4_append([sentence], [symbol.])dnl |
| 2040 # | sentence |
| 2041 # | m4_undefine([active])dnl |
| 2042 # | sentence |
| 2043 # => This is an ACTIVE symbol. |
| 2044 # => This is an active symbol. |
| 2045 # |
| 2046 # It can be used to define hooks. |
| 2047 # |
| 2048 # | m4_define(active, ACTIVE)dnl |
| 2049 # | m4_append([hooks], [m4_define([act1], [act2])])dnl |
| 2050 # | m4_append([hooks], [m4_define([act2], [active])])dnl |
| 2051 # | m4_undefine([active])dnl |
| 2052 # | act1 |
| 2053 # | hooks |
| 2054 # | act1 |
| 2055 # => act1 |
| 2056 # => |
| 2057 # => active |
| 2058 # |
| 2059 # It can also be used to create lists, although this particular usage was |
| 2060 # broken prior to autoconf 2.62. |
| 2061 # | m4_append([list], [one], [, ])dnl |
| 2062 # | m4_append([list], [two], [, ])dnl |
| 2063 # | m4_append([list], [three], [, ])dnl |
| 2064 # | list |
| 2065 # | m4_dquote(list) |
| 2066 # => one, two, three |
| 2067 # => [one],[two],[three] |
| 2068 # |
| 2069 # Note that m4_append can benefit from amortized O(n) m4 behavior, if |
| 2070 # the underlying m4 implementation is smart enough to avoid copying existing |
| 2071 # contents when enlarging a macro's definition into any pre-allocated storage |
| 2072 # (m4 1.4.x unfortunately does not implement this optimization). We do |
| 2073 # not implement m4_prepend, since it is inherently O(n^2) (pre-allocated |
| 2074 # storage only occurs at the end of a macro, so the existing contents must |
| 2075 # always be moved). |
| 2076 # |
| 2077 # Use _m4_defn for speed. |
| 2078 m4_define([m4_append], |
| 2079 [m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) |
| 2080 |
| 2081 |
| 2082 # m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) |
| 2083 # -------------------------------------------------------------------- |
| 2084 # Like `m4_append', but append only if not yet present. Additionally, |
| 2085 # expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already |
| 2086 # present. Also, warn if SEPARATOR is not empty and occurs within STRING, |
| 2087 # as the algorithm no longer guarantees uniqueness. |
| 2088 # |
| 2089 # Note that while m4_append can be O(n) (depending on the quality of the |
| 2090 # underlying M4 implementation), m4_append_uniq is inherently O(n^2) |
| 2091 # because each append operation searches the entire string. |
| 2092 m4_define([m4_append_uniq], |
| 2093 [m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], |
| 2094 [m4_warn([syntax], |
| 2095 [$0: `$2' contains `$3'])])])_$0($@)]) |
| 2096 m4_define([_m4_append_uniq], |
| 2097 [m4_ifdef([$1], |
| 2098 [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], |
| 2099 [m4_append([$1], [$2], [$3])$4], [$5])], |
| 2100 [m4_define([$1], [$2])$4])]) |
| 2101 |
| 2102 # m4_append_uniq_w(MACRO-NAME, STRINGS) |
| 2103 # ------------------------------------- |
| 2104 # For each of the words in the whitespace separated list STRINGS, append |
| 2105 # only the unique strings to the definition of MACRO-NAME. |
| 2106 # |
| 2107 # Use _m4_defn for speed. |
| 2108 m4_define([m4_append_uniq_w], |
| 2109 [m4_foreach_w([m4_Word], [$2], |
| 2110 [_m4_append_uniq([$1], _m4_defn([m4_Word]), [ ])])]) |
| 2111 |
| 2112 |
| 2113 # m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) |
| 2114 # ------------------------------------------------------- |
| 2115 # Expands into STRING wrapped to hold in WIDTH columns (default = 79). |
| 2116 # If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is |
| 2117 # specified, then the first line is prefixed with it. As a special case, |
| 2118 # if the length of FIRST-PREFIX is greater than that of PREFIX, then |
| 2119 # FIRST-PREFIX will be left alone on the first line. |
| 2120 # |
| 2121 # No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, |
| 2122 # although quadrigraphs are correctly recognized. |
| 2123 # |
| 2124 # Typical outputs are: |
| 2125 # |
| 2126 # m4_text_wrap([Short string */], [ ], [/* ], 20) |
| 2127 # => /* Short string */ |
| 2128 # |
| 2129 # m4_text_wrap([Much longer string */], [ ], [/* ], 20) |
| 2130 # => /* Much longer |
| 2131 # => string */ |
| 2132 # |
| 2133 # m4_text_wrap([Short doc.], [ ], [ --short ], 30) |
| 2134 # => --short Short doc. |
| 2135 # |
| 2136 # m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) |
| 2137 # => --too-wide |
| 2138 # => Short doc. |
| 2139 # |
| 2140 # m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) |
| 2141 # => --too-wide |
| 2142 # => Super long |
| 2143 # => documentation. |
| 2144 # |
| 2145 # FIXME: there is no checking of a longer PREFIX than WIDTH, but do |
| 2146 # we really want to bother with people trying each single corner |
| 2147 # of a software? |
| 2148 # |
| 2149 # This macro does not leave a trailing space behind the last word of a line, |
| 2150 # which complicates it a bit. The algorithm is otherwise stupid and simple: |
| 2151 # all the words are preceded by m4_Separator which is defined to empty for |
| 2152 # the first word, and then ` ' (single space) for all the others. |
| 2153 # |
| 2154 # The algorithm uses a helper that uses $2 through $4 directly, rather than |
| 2155 # using local variables, to avoid m4_defn overhead, or expansion swallowing |
| 2156 # any $. It also bypasses m4_popdef overhead with _m4_popdef since no user |
| 2157 # macro expansion occurs in the meantime. Also, the definition is written |
| 2158 # with m4_do, to avoid time wasted on dnl during expansion (since this is |
| 2159 # already a time-consuming macro). |
| 2160 m4_define([m4_text_wrap], |
| 2161 [_$0([$1], [$2], m4_if([$3], [], [[$2]], [[$3]]), |
| 2162 m4_if([$4], [], [79], [[$4]]))]) |
| 2163 m4_define([_m4_text_wrap], |
| 2164 m4_do(dnl set up local variables, to avoid repeated calculations |
| 2165 [[m4_pushdef([m4_Indent], m4_qlen([$2]))]], |
| 2166 [[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], |
| 2167 [[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], |
| 2168 dnl expand the first prefix, then check its length vs. regular prefix |
| 2169 dnl same length: nothing special |
| 2170 dnl prefix1 longer: output on line by itself, and reset cursor |
| 2171 dnl prefix1 shorter: pad to length of prefix, and reset cursor |
| 2172 [[[$3]m4_cond([m4_Cursor], m4_Indent, [], |
| 2173 [m4_eval(m4_Cursor > m4_Indent)], [1], [ |
| 2174 [$2]m4_define([m4_Cursor], m4_Indent)], |
| 2175 [m4_format([%*s], m4_max([0], |
| 2176 m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], |
| 2177 dnl now, for each word, compute the curser after the word is output, then |
| 2178 dnl check if the cursor would exceed the wrap column |
| 2179 dnl if so, reset cursor, and insert newline and prefix |
| 2180 dnl if not, insert the separator (usually a space) |
| 2181 dnl either way, insert the word |
| 2182 [[m4_foreach_w([m4_Word], [$1], |
| 2183 [m4_define([m4_Cursor], |
| 2184 m4_eval(m4_Cursor + m4_qlen(_m4_defn([m4_Word])) |
| 2185 + 1))m4_if(m4_eval(m4_Cursor > ([$4])), |
| 2186 [1], [m4_define([m4_Cursor], |
| 2187 m4_eval(m4_Indent + m4_qlen(_m4_defn([m4_Word])) + 1)) |
| 2188 [$2]], |
| 2189 [m4_Separator[]])_m4_defn([m4_Word])])]], |
| 2190 dnl finally, clean up the local variabls |
| 2191 [[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) |
| 2192 |
| 2193 |
| 2194 # m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) |
| 2195 # --------------------------------------------- |
| 2196 # Turn MESSAGE into: |
| 2197 # ## ------- ## |
| 2198 # ## MESSAGE ## |
| 2199 # ## ------- ## |
| 2200 # using FRAME-CHARACTER in the border. |
| 2201 m4_define([m4_text_box], |
| 2202 [m4_pushdef([m4_Border], |
| 2203 m4_translit(m4_format([%*s], m4_qlen(m4_expand([$1])), []), |
| 2204 [ ], m4_if([$2], [], [[-]], [[$2]])))dnl |
| 2205 @%:@@%:@ m4_Border @%:@@%:@ |
| 2206 @%:@@%:@ $1 @%:@@%:@ |
| 2207 @%:@@%:@ m4_Border @%:@@%:@_m4_popdef([m4_Border])dnl |
| 2208 ]) |
| 2209 |
| 2210 |
| 2211 # m4_qlen(STRING) |
| 2212 # --------------- |
| 2213 # Expands to the length of STRING after autom4te converts all quadrigraphs. |
| 2214 # |
| 2215 # Avoid bpatsubsts for the common case of no quadrigraphs. |
| 2216 m4_define([m4_qlen], |
| 2217 [m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], |
| 2218 [m4_len(m4_bpatsubst([[$1]], |
| 2219 [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], |
| 2220 [\3]))])]) |
| 2221 |
| 2222 |
| 2223 # m4_qdelta(STRING) |
| 2224 # ----------------- |
| 2225 # Expands to the net change in the length of STRING from autom4te converting the |
| 2226 # quadrigraphs in STRING. This number is always negative or zero. |
| 2227 m4_define([m4_qdelta], |
| 2228 [m4_eval(m4_qlen([$1]) - m4_len([$1]))]) |
| 2229 |
| 2230 |
| 2231 |
| 2232 ## ----------------------- ## |
| 2233 ## 13. Number processing. ## |
| 2234 ## ----------------------- ## |
| 2235 |
| 2236 # m4_cmp(A, B) |
| 2237 # ------------ |
| 2238 # Compare two integer expressions. |
| 2239 # A < B -> -1 |
| 2240 # A = B -> 0 |
| 2241 # A > B -> 1 |
| 2242 m4_define([m4_cmp], |
| 2243 [m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) |
| 2244 |
| 2245 |
| 2246 # m4_list_cmp(A, B) |
| 2247 # ----------------- |
| 2248 # |
| 2249 # Compare the two lists of integer expressions A and B. For instance: |
| 2250 # m4_list_cmp([1, 0], [1]) -> 0 |
| 2251 # m4_list_cmp([1, 0], [1, 0]) -> 0 |
| 2252 # m4_list_cmp([1, 2], [1, 0]) -> 1 |
| 2253 # m4_list_cmp([1, 2, 3], [1, 2]) -> 1 |
| 2254 # m4_list_cmp([1, 2, -3], [1, 2]) -> -1 |
| 2255 # m4_list_cmp([1, 0], [1, 2]) -> -1 |
| 2256 # m4_list_cmp([1], [1, 2]) -> -1 |
| 2257 # m4_define([xa], [oops])dnl |
| 2258 # m4_list_cmp([[0xa]], [5+5]) -> 0 |
| 2259 # |
| 2260 # Rather than face the overhead of m4_case, we use a helper function whose |
| 2261 # expansion includes the name of the macro to invoke on the tail, either |
| 2262 # m4_ignore or m4_unquote. This is particularly useful when comparing |
| 2263 # long lists, since less text is being expanded for deciding when to end |
| 2264 # recursion. The recursion is between a pair of macros that alternate |
| 2265 # which list is trimmed by one element; this is more efficient than |
| 2266 # calling m4_cdr on both lists from a single macro. Guarantee exactly |
| 2267 # one expansion of both lists' side effects. |
| 2268 # |
| 2269 # Please keep foreach.m4 in sync with any adjustments made here. |
| 2270 m4_define([m4_list_cmp], |
| 2271 [_$0_raw(m4_dquote($1), m4_dquote($2))]) |
| 2272 |
| 2273 m4_define([_m4_list_cmp_raw], |
| 2274 [m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) |
| 2275 |
| 2276 m4_define([_m4_list_cmp], |
| 2277 [m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) |
| 2278 |
| 2279 m4_define([_m4_list_cmp_1], |
| 2280 [_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) |
| 2281 |
| 2282 m4_define([_m4_list_cmp_2], |
| 2283 [_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( |
| 2284 [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) |
| 2285 |
| 2286 # m4_max(EXPR, ...) |
| 2287 # m4_min(EXPR, ...) |
| 2288 # ----------------- |
| 2289 # Return the decimal value of the maximum (or minimum) in a series of |
| 2290 # integer expressions. |
| 2291 # |
| 2292 # M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval |
| 2293 # if both arguments are identical, but be aware of m4_max(0xa, 10) (hence |
| 2294 # the use of <=, not just <, in the second multiply). |
| 2295 # |
| 2296 # Please keep foreach.m4 in sync with any adjustments made here. |
| 2297 m4_define([m4_max], |
| 2298 [m4_if([$#], [0], [m4_fatal([too few arguments to $0])], |
| 2299 [$#], [1], [m4_eval([$1])], |
| 2300 [$#$1], [2$2], [m4_eval([$1])], |
| 2301 [$#], [2], [_$0($@)], |
| 2302 [_m4_minmax([_$0], $@)])]) |
| 2303 |
| 2304 m4_define([_m4_max], |
| 2305 [m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) |
| 2306 |
| 2307 m4_define([m4_min], |
| 2308 [m4_if([$#], [0], [m4_fatal([too few arguments to $0])], |
| 2309 [$#], [1], [m4_eval([$1])], |
| 2310 [$#$1], [2$2], [m4_eval([$1])], |
| 2311 [$#], [2], [_$0($@)], |
| 2312 [_m4_minmax([_$0], $@)])]) |
| 2313 |
| 2314 m4_define([_m4_min], |
| 2315 [m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) |
| 2316 |
| 2317 # _m4_minmax(METHOD, ARG1, ARG2...) |
| 2318 # --------------------------------- |
| 2319 # Common recursion code for m4_max and m4_min. METHOD must be _m4_max |
| 2320 # or _m4_min, and there must be at least two arguments to combine. |
| 2321 # |
| 2322 # Please keep foreach.m4 in sync with any adjustments made here. |
| 2323 m4_define([_m4_minmax], |
| 2324 [m4_if([$#], [3], [$1([$2], [$3])], |
| 2325 [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) |
| 2326 |
| 2327 |
| 2328 # m4_sign(A) |
| 2329 # ---------- |
| 2330 # The sign of the integer expression A. |
| 2331 m4_define([m4_sign], |
| 2332 [m4_eval((([$1]) > 0) - (([$1]) < 0))]) |
| 2333 |
| 2334 |
| 2335 |
| 2336 ## ------------------------ ## |
| 2337 ## 14. Version processing. ## |
| 2338 ## ------------------------ ## |
| 2339 |
| 2340 |
| 2341 # m4_version_unletter(VERSION) |
| 2342 # ---------------------------- |
| 2343 # Normalize beta version numbers with letters to numeric expressions, which |
| 2344 # can then be handed to m4_eval for the purpose of comparison. |
| 2345 # |
| 2346 # Nl -> (N+1).-1.(l#) |
| 2347 # |
| 2348 # for example: |
| 2349 # [2.14a] -> [2.14+1.-1.[0r36:a]] -> 2.15.-1.10 |
| 2350 # [2.14b] -> [2.15+1.-1.[0r36:b]] -> 2.15.-1.11 |
| 2351 # [2.61aa.b] -> [2.61+1.-1.[0r36:aa],+1.-1.[0r36:b]] -> 2.62.-1.370.1.-1.11 |
| 2352 # |
| 2353 # This macro expects reasonable version numbers, but can handle double |
| 2354 # letters and does not expand any macros. Original version strings can |
| 2355 # use both `.' and `-' separators. |
| 2356 # |
| 2357 # Inline constant expansions, to avoid m4_defn overhead. |
| 2358 # _m4_version_unletter is the real workhorse used by m4_version_compare, |
| 2359 # but since [0r36:a] is less readable than 10, we provide a wrapper for |
| 2360 # human use. |
| 2361 m4_define([m4_version_unletter], |
| 2362 [m4_map_sep([m4_eval], [.], |
| 2363 m4_dquote(m4_dquote_elt(m4_unquote(_$0([$1])))))]) |
| 2364 m4_define([_m4_version_unletter], |
| 2365 [m4_bpatsubst(m4_translit([[[$1]]], [.-], [,,]),]dnl |
| 2366 m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], |
| 2367 [+1,-1,[0r36:\&]])]) |
| 2368 |
| 2369 |
| 2370 # m4_version_compare(VERSION-1, VERSION-2) |
| 2371 # ---------------------------------------- |
| 2372 # Compare the two version numbers and expand into |
| 2373 # -1 if VERSION-1 < VERSION-2 |
| 2374 # 0 if = |
| 2375 # 1 if > |
| 2376 # |
| 2377 # Since _m4_version_unletter does not output side effects, we can |
| 2378 # safely bypass the overhead of m4_version_cmp. |
| 2379 m4_define([m4_version_compare], |
| 2380 [_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) |
| 2381 |
| 2382 |
| 2383 # m4_PACKAGE_NAME |
| 2384 # m4_PACKAGE_TARNAME |
| 2385 # m4_PACKAGE_VERSION |
| 2386 # m4_PACKAGE_STRING |
| 2387 # m4_PACKAGE_BUGREPORT |
| 2388 # -------------------- |
| 2389 # If m4sugar/version.m4 is present, then define version strings. This |
| 2390 # file is optional, provided by Autoconf but absent in Bison. |
| 2391 m4_sinclude([m4sugar/version.m4]) |
| 2392 |
| 2393 |
| 2394 # m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) |
| 2395 # ---------------------------------------------------- |
| 2396 # Check this Autoconf version against VERSION. |
| 2397 m4_define([m4_version_prereq], |
| 2398 m4_ifdef([m4_PACKAGE_VERSION], |
| 2399 [[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), |
| 2400 [-1], |
| 2401 [m4_default([$3], |
| 2402 [m4_fatal([Autoconf version $1 or higher is required], |
| 2403 [63])])], |
| 2404 [$2])]], |
| 2405 [[m4_fatal([m4sugar/version.m4 not found])]])) |
| 2406 |
| 2407 |
| 2408 ## ------------------ ## |
| 2409 ## 15. Set handling. ## |
| 2410 ## ------------------ ## |
| 2411 |
| 2412 # Autoconf likes to create arbitrarily large sets; for example, as of |
| 2413 # this writing, the configure.ac for coreutils tracks a set of more |
| 2414 # than 400 AC_SUBST. How do we track all of these set members, |
| 2415 # without introducing duplicates? We could use m4_append_uniq, with |
| 2416 # the set NAME residing in the contents of the macro NAME. |
| 2417 # Unfortunately, m4_append_uniq is quadratic for set creation, because |
| 2418 # it costs O(n) to search the string for each of O(n) insertions; not |
| 2419 # to mention that with m4 1.4.x, even using m4_append is slow, costing |
| 2420 # O(n) rather than O(1) per insertion. Other set operations, not used |
| 2421 # by Autoconf but still possible by manipulation of the definition |
| 2422 # tracked in macro NAME, include O(n) deletion of one element and O(n) |
| 2423 # computation of set size. Because the set is exposed to the user via |
| 2424 # the definition of a single macro, we cannot cache any data about the |
| 2425 # set without risking the cache being invalidated by the user |
| 2426 # redefining NAME. |
| 2427 # |
| 2428 # Can we do better? Yes, because m4 gives us an O(1) search function |
| 2429 # for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) |
| 2430 # insert operation for free: pushdef. But to use these, we must |
| 2431 # represent the set via a group of macros; to keep the set consistent, |
| 2432 # we must hide the set so that the user can only manipulate it through |
| 2433 # accessor macros. The contents of the set are maintained through two |
| 2434 # access points; _m4_set([name]) is a pushdef stack of values in the |
| 2435 # set, useful for O(n) traversal of the set contents; while the |
| 2436 # existence of _m4_set([name],value) with no particular value is |
| 2437 # useful for O(1) querying of set membership. And since the user |
| 2438 # cannot externally manipulate the set, we are free to add additional |
| 2439 # caching macros for other performance improvements. Deletion can be |
| 2440 # O(1) per element rather than O(n), by reworking the definition of |
| 2441 # _m4_set([name],value) to be 0 or 1 based on current membership, and |
| 2442 # adding _m4_set_cleanup(name) to defer the O(n) cleanup of |
| 2443 # _m4_set([name]) until we have another reason to do an O(n) |
| 2444 # traversal. The existence of _m4_set_cleanup(name) can then be used |
| 2445 # elsewhere to determine if we must dereference _m4_set([name],value), |
| 2446 # or assume that definition implies set membership. Finally, size can |
| 2447 # be tracked in an O(1) fashion with _m4_set_size(name). |
| 2448 # |
| 2449 # The quoting in _m4_set([name],value) is chosen so that there is no |
| 2450 # ambiguity with a set whose name contains a comma, and so that we can |
| 2451 # supply the value via _m4_defn([_m4_set([name])]) without needing any |
| 2452 # quote manipulation. |
| 2453 |
| 2454 # m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) |
| 2455 # ------------------------------------------- |
| 2456 # Add VALUE as an element of SET. Expand IF-UNIQ on the first |
| 2457 # addition, and IF-DUP if it is already in the set. Addition of one |
| 2458 # element is O(1), such that overall set creation is O(n). |
| 2459 # |
| 2460 # We do not want to add a duplicate for a previously deleted but |
| 2461 # unpruned element, but it is just as easy to check existence directly |
| 2462 # as it is to query _m4_set_cleanup($1). |
| 2463 m4_define([m4_set_add], |
| 2464 [m4_ifdef([_m4_set([$1],$2)], |
| 2465 [m4_if(m4_indir([_m4_set([$1],$2)]), [0], |
| 2466 [m4_define([_m4_set([$1],$2)], |
| 2467 [1])_m4_set_size([$1], [m4_incr])$3], [$4])], |
| 2468 [m4_define([_m4_set([$1],$2)], |
| 2469 [1])m4_pushdef([_m4_set([$1])], |
| 2470 [$2])_m4_set_size([$1], [m4_incr])$3])]) |
| 2471 |
| 2472 # m4_set_add_all(SET, VALUE...) |
| 2473 # ----------------------------- |
| 2474 # Add each VALUE into SET. This is O(n) in the number of VALUEs, and |
| 2475 # can be faster than calling m4_set_add for each VALUE. |
| 2476 # |
| 2477 # Implement two recursion helpers; the check variant is slower but |
| 2478 # handles the case where an element has previously been removed but |
| 2479 # not pruned. The recursion helpers ignore their second argument, so |
| 2480 # that we can use the faster m4_shift2 and 2 arguments, rather than |
| 2481 # _m4_shift2 and one argument, as the signal to end recursion. |
| 2482 # |
| 2483 # Please keep foreach.m4 in sync with any adjustments made here. |
| 2484 m4_define([m4_set_add_all], |
| 2485 [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) |
| 2486 + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) |
| 2487 |
| 2488 m4_define([_m4_set_add_all], |
| 2489 [m4_if([$#], [2], [], |
| 2490 [m4_ifdef([_m4_set([$1],$3)], [], |
| 2491 [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], |
| 2492 [$3])-])$0([$1], m4_shift2($@))])]) |
| 2493 |
| 2494 m4_define([_m4_set_add_all_check], |
| 2495 [m4_if([$#], [2], [], |
| 2496 [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) |
| 2497 |
| 2498 # m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) |
| 2499 # ------------------------------------------------------ |
| 2500 # Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. |
| 2501 # This is always O(1). |
| 2502 m4_define([m4_set_contains], |
| 2503 [m4_ifdef([_m4_set_cleanup($1)], |
| 2504 [m4_if(m4_ifdef([_m4_set([$1],$2)], |
| 2505 [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], |
| 2506 [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) |
| 2507 |
| 2508 # m4_set_contents(SET, [SEP]) |
| 2509 # --------------------------- |
| 2510 # Expand to a single string containing all the elements in SET, |
| 2511 # separated by SEP, without modifying SET. No provision is made for |
| 2512 # disambiguating set elements that contain non-empty SEP as a |
| 2513 # sub-string, or for recognizing a set that contains only the empty |
| 2514 # string. Order of the output is not guaranteed. If any elements |
| 2515 # have been previously removed from the set, this action will prune |
| 2516 # the unused memory. This is O(n) in the size of the set before |
| 2517 # pruning. |
| 2518 # |
| 2519 # Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) |
| 2520 # determines which version of _1 helper we use. |
| 2521 m4_define([m4_set_contents], |
| 2522 [m4_ifdef([_m4_set_cleanup($1)], [_$0_1c], [_$0_1])([$1])_$0_2([$1], |
| 2523 [_m4_defn([_m4_set_($1)])], [[$2]])]) |
| 2524 |
| 2525 # _m4_set_contents_1(SET) |
| 2526 # _m4_set_contents_1c(SET) |
| 2527 # _m4_set_contents_2(SET, SEP, PREP) |
| 2528 # ---------------------------------- |
| 2529 # Expand to a list of quoted elements currently in the set, separated |
| 2530 # by SEP, and moving PREP in front of SEP on recursion. To avoid |
| 2531 # nesting limit restrictions, the algorithm must be broken into two |
| 2532 # parts; _1 destructively copies the stack in reverse into |
| 2533 # _m4_set_($1), producing no output; then _2 destructively copies |
| 2534 # _m4_set_($1) back into the stack in reverse. SEP is expanded while |
| 2535 # _m4_set_($1) contains the current element, so a SEP containing |
| 2536 # _m4_defn([_m4_set_($1)]) can produce output in the order the set was |
| 2537 # created. Behavior is undefined if SEP tries to recursively list or |
| 2538 # modify SET in any way other than calling m4_set_remove on the |
| 2539 # current element. Use _1 if all entries in the stack are guaranteed |
| 2540 # to be in the set, and _1c to prune removed entries. Uses _m4_defn |
| 2541 # and _m4_popdef for speed. |
| 2542 m4_define([_m4_set_contents_1], |
| 2543 [m4_ifdef([_m4_set([$1])], [m4_pushdef([_m4_set_($1)], |
| 2544 _m4_defn([_m4_set([$1])]))_m4_popdef([_m4_set([$1])])$0([$1])])]) |
| 2545 |
| 2546 m4_define([_m4_set_contents_1c], |
| 2547 [m4_ifdef([_m4_set([$1])], |
| 2548 [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), |
| 2549 [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], |
| 2550 [_m4_popdef([_m4_set([$1],]_m4_defn( |
| 2551 [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], |
| 2552 [_m4_popdef([_m4_set_cleanup($1)])])]) |
| 2553 |
| 2554 m4_define([_m4_set_contents_2], |
| 2555 [m4_ifdef([_m4_set_($1)], [m4_pushdef([_m4_set([$1])], |
| 2556 _m4_defn([_m4_set_($1)]))$2[]_m4_popdef([_m4_set_($1)])$0([$1], [$3$2])])]) |
| 2557 |
| 2558 # m4_set_delete(SET) |
| 2559 # ------------------ |
| 2560 # Delete all elements in SET, and reclaim any memory occupied by the |
| 2561 # set. This is O(n) in the set size. |
| 2562 # |
| 2563 # Use _m4_defn and _m4_popdef for speed. |
| 2564 m4_define([m4_set_delete], |
| 2565 [m4_ifdef([_m4_set([$1])], |
| 2566 [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], |
| 2567 [_m4_set([$1])])$0([$1])], |
| 2568 [m4_ifdef([_m4_set_cleanup($1)], |
| 2569 [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( |
| 2570 [_m4_set_size($1)], |
| 2571 [_m4_popdef([_m4_set_size($1)])])])]) |
| 2572 |
| 2573 # m4_set_difference(SET1, SET2) |
| 2574 # ----------------------------- |
| 2575 # Produce a LIST of quoted elements that occur in SET1 but not SET2. |
| 2576 # Output a comma prior to any elements, to distinguish the empty |
| 2577 # string from no elements. This can be directly used as a series of |
| 2578 # arguments, such as for m4_join, or wrapped inside quotes for use in |
| 2579 # m4_foreach. Order of the output is not guaranteed. |
| 2580 # |
| 2581 # Short-circuit the idempotence relation. Use _m4_defn for speed. |
| 2582 m4_define([m4_set_difference], |
| 2583 [m4_if([$1], [$2], [], |
| 2584 [m4_set_foreach([$1], [_m4_element], |
| 2585 [m4_set_contains([$2], _m4_defn([_m4_element]), [], |
| 2586 [,_m4_defn([_m4_element])])])])]) |
| 2587 |
| 2588 # m4_set_dump(SET, [SEP]) |
| 2589 # ----------------------- |
| 2590 # Expand to a single string containing all the elements in SET, |
| 2591 # separated by SEP, then delete SET. In general, if you only need to |
| 2592 # list the contents once, this is faster than m4_set_contents. No |
| 2593 # provision is made for disambiguating set elements that contain |
| 2594 # non-empty SEP as a sub-string. Order of the output is not |
| 2595 # guaranteed. This is O(n) in the size of the set before pruning. |
| 2596 # |
| 2597 # Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to |
| 2598 # decide if more expensive recursion is needed. |
| 2599 m4_define([m4_set_dump], |
| 2600 [m4_ifdef([_m4_set_size($1)], |
| 2601 [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], |
| 2602 [_$0_check], [_$0])([$1], [], [$2])]) |
| 2603 |
| 2604 # _m4_set_dump(SET, SEP, PREP) |
| 2605 # _m4_set_dump_check(SET, SEP, PREP) |
| 2606 # ---------------------------------- |
| 2607 # Print SEP and the current element, then delete the element and |
| 2608 # recurse with empty SEP changed to PREP. The check variant checks |
| 2609 # whether the element has been previously removed. Use _m4_defn and |
| 2610 # _m4_popdef for speed. |
| 2611 m4_define([_m4_set_dump], |
| 2612 [m4_ifdef([_m4_set([$1])], |
| 2613 [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( |
| 2614 [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) |
| 2615 |
| 2616 m4_define([_m4_set_dump_check], |
| 2617 [m4_ifdef([_m4_set([$1])], |
| 2618 [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), |
| 2619 [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( |
| 2620 [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], |
| 2621 [_m4_set([$1])])$0([$1], [$2$3])], |
| 2622 [_m4_popdef([_m4_set_cleanup($1)])])]) |
| 2623 |
| 2624 # m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) |
| 2625 # -------------------------------------------- |
| 2626 # Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. |
| 2627 m4_define([m4_set_empty], |
| 2628 [m4_ifdef([_m4_set_size($1)], |
| 2629 [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) |
| 2630 |
| 2631 # m4_set_foreach(SET, VAR, ACTION) |
| 2632 # -------------------------------- |
| 2633 # For each element of SET, define VAR to the element and expand |
| 2634 # ACTION. ACTION should not recursively list SET's contents, add |
| 2635 # elements to SET, nor delete any element from SET except the one |
| 2636 # currently in VAR. The order that the elements are visited in is not |
| 2637 # guaranteed. This is faster than the corresponding m4_foreach([VAR], |
| 2638 # m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) |
| 2639 m4_define([m4_set_foreach], |
| 2640 [m4_pushdef([$2])m4_ifdef([_m4_set_cleanup($1)], |
| 2641 [_m4_set_contents_1c], [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], |
| 2642 [m4_define([$2], _m4_defn([_m4_set_($1)]))$3[]])m4_popdef([$2])]) |
| 2643 |
| 2644 # m4_set_intersection(SET1, SET2) |
| 2645 # ------------------------------- |
| 2646 # Produce a LIST of quoted elements that occur in both SET1 or SET2. |
| 2647 # Output a comma prior to any elements, to distinguish the empty |
| 2648 # string from no elements. This can be directly used as a series of |
| 2649 # arguments, such as for m4_join, or wrapped inside quotes for use in |
| 2650 # m4_foreach. Order of the output is not guaranteed. |
| 2651 # |
| 2652 # Iterate over the smaller set, and short-circuit the idempotence |
| 2653 # relation. Use _m4_defn for speed. |
| 2654 m4_define([m4_set_intersection], |
| 2655 [m4_if([$1], [$2], [m4_set_listc([$1])], |
| 2656 m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], |
| 2657 [m4_set_foreach([$1], [_m4_element], |
| 2658 [m4_set_contains([$2], _m4_defn([_m4_element]), |
| 2659 [,_m4_defn([_m4_element])])])])]) |
| 2660 |
| 2661 # m4_set_list(SET) |
| 2662 # m4_set_listc(SET) |
| 2663 # ----------------- |
| 2664 # Produce a LIST of quoted elements of SET. This can be directly used |
| 2665 # as a series of arguments, such as for m4_join or m4_set_add_all, or |
| 2666 # wrapped inside quotes for use in m4_foreach or m4_map. With |
| 2667 # m4_set_list, there is no way to distinguish an empty set from a set |
| 2668 # containing only the empty string; with m4_set_listc, a leading comma |
| 2669 # is output if there are any elements. |
| 2670 m4_define([m4_set_list], |
| 2671 [m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], |
| 2672 [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], |
| 2673 [_m4_defn([_m4_set_($1)])], [,])]) |
| 2674 |
| 2675 m4_define([m4_set_listc], |
| 2676 [m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], |
| 2677 [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], |
| 2678 [,_m4_defn([_m4_set_($1)])])]) |
| 2679 |
| 2680 # m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) |
| 2681 # ---------------------------------------------------- |
| 2682 # If VALUE is an element of SET, delete it and expand IF-PRESENT. |
| 2683 # Otherwise expand IF-ABSENT. Deleting a single value is O(1), |
| 2684 # although it leaves memory occupied until the next O(n) traversal of |
| 2685 # the set which will compact the set. |
| 2686 # |
| 2687 # Optimize if the element being removed is the most recently added, |
| 2688 # since defining _m4_set_cleanup($1) slows down so many other macros. |
| 2689 # In particular, this plays well with m4_set_foreach. |
| 2690 m4_define([m4_set_remove], |
| 2691 [m4_set_contains([$1], [$2], [_m4_set_size([$1], |
| 2692 [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], |
| 2693 [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], |
| 2694 [m4_define([_m4_set_cleanup($1)])m4_define( |
| 2695 [_m4_set([$1],$2)], [0])])$3], [$4])]) |
| 2696 |
| 2697 # m4_set_size(SET) |
| 2698 # ---------------- |
| 2699 # Expand to the number of elements currently in SET. This operation |
| 2700 # is O(1), and thus more efficient than m4_count(m4_set_list([SET])). |
| 2701 m4_define([m4_set_size], |
| 2702 [m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) |
| 2703 |
| 2704 # _m4_set_size(SET, ACTION) |
| 2705 # ------------------------- |
| 2706 # ACTION must be either m4_incr or m4_decr, and the size of SET is |
| 2707 # changed accordingly. If the set is empty, ACTION must not be |
| 2708 # m4_decr. |
| 2709 m4_define([_m4_set_size], |
| 2710 [m4_define([_m4_set_size($1)], |
| 2711 m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], |
| 2712 [1]))]) |
| 2713 |
| 2714 # m4_set_union(SET1, SET2) |
| 2715 # ------------------------ |
| 2716 # Produce a LIST of double quoted elements that occur in either SET1 |
| 2717 # or SET2, without duplicates. Output a comma prior to any elements, |
| 2718 # to distinguish the empty string from no elements. This can be |
| 2719 # directly used as a series of arguments, such as for m4_join, or |
| 2720 # wrapped inside quotes for use in m4_foreach. Order of the output is |
| 2721 # not guaranteed. |
| 2722 # |
| 2723 # We can rely on the fact that m4_set_listc prunes SET1, so we don't |
| 2724 # need to check _m4_set([$1],element) for 0. Use _m4_defn for speed. |
| 2725 # Short-circuit the idempotence relation. |
| 2726 m4_define([m4_set_union], |
| 2727 [m4_set_listc([$1])m4_if([$1], [$2], [], [m4_set_foreach([$2], [_m4_element], |
| 2728 [m4_ifdef([_m4_set([$1],]_m4_defn([_m4_element])[)], [], |
| 2729 [,_m4_defn([_m4_element])])])])]) |
| 2730 |
| 2731 |
| 2732 ## ------------------- ## |
| 2733 ## 16. File handling. ## |
| 2734 ## ------------------- ## |
| 2735 |
| 2736 |
| 2737 # It is a real pity that M4 comes with no macros to bind a diversion |
| 2738 # to a file. So we have to deal without, which makes us a lot more |
| 2739 # fragile than we should. |
| 2740 |
| 2741 |
| 2742 # m4_file_append(FILE-NAME, CONTENT) |
| 2743 # ---------------------------------- |
| 2744 m4_define([m4_file_append], |
| 2745 [m4_syscmd([cat >>$1 <<_m4eof |
| 2746 $2 |
| 2747 _m4eof |
| 2748 ]) |
| 2749 m4_if(m4_sysval, [0], [], |
| 2750 [m4_fatal([$0: cannot write: $1])])]) |
| 2751 |
| 2752 |
| 2753 |
| 2754 ## ------------------------ ## |
| 2755 ## 17. Setting M4sugar up. ## |
| 2756 ## ------------------------ ## |
| 2757 |
| 2758 |
| 2759 # m4_init |
| 2760 # ------- |
| 2761 # Initialize the m4sugar language. |
| 2762 m4_define([m4_init], |
| 2763 [# All the M4sugar macros start with `m4_', except `dnl' kept as is |
| 2764 # for sake of simplicity. |
| 2765 m4_pattern_forbid([^_?m4_]) |
| 2766 m4_pattern_forbid([^dnl$]) |
| 2767 |
| 2768 # If __m4_version__ is defined, we assume that we are being run by M4 |
| 2769 # 1.6 or newer, and thus that $@ recursion is linear and debugmode(d) |
| 2770 # is available for faster checks of dereferencing undefined macros. |
| 2771 # But if it is missing, we assume we are being run by M4 1.4.x, that |
| 2772 # $@ recursion is quadratic, and that we need foreach-based |
| 2773 # replacement macros. Use the raw builtin to avoid tripping up |
| 2774 # include tracing. |
| 2775 m4_ifdef([__m4_version__], |
| 2776 [m4_debugmode([+d]) |
| 2777 m4_copy([_m4_defn], [m4_defn]) |
| 2778 m4_copy([_m4_popdef], [m4_popdef]) |
| 2779 m4_copy([_m4_undefine], [m4_undefine])], |
| 2780 [m4_builtin([include], [m4sugar/foreach.m4])]) |
| 2781 |
| 2782 # _m4_divert_diversion should be defined: |
| 2783 m4_divert_push([KILL]) |
| 2784 |
| 2785 # Check the divert push/pop perfect balance. |
| 2786 m4_wrap([m4_divert_pop([]) |
| 2787 m4_ifdef([_m4_divert_diversion], |
| 2788 [m4_fatal([$0: unbalanced m4_divert_push:]_m4_divert_n_stack)])[]]) |
| 2789 ]) |
OLD | NEW |