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