# -*- Autoconf -*- | |
# This file is part of Autoconf. | |
# foreach-based replacements for recursive functions. | |
# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes | |
# GNU M4 1.6 by requiring more memory and macro expansions. | |
# | |
# Copyright (C) 2008-2012 Free Software Foundation, Inc. | |
# This file is part of Autoconf. This program is free | |
# software; you can redistribute it and/or modify it under the | |
# terms of the GNU General Public License as published by the | |
# Free Software Foundation, either version 3 of the License, or | |
# (at your option) any later version. | |
# | |
# This program is distributed in the hope that it will be useful, | |
# but WITHOUT ANY WARRANTY; without even the implied warranty of | |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
# GNU General Public License for more details. | |
# | |
# Under Section 7 of GPL version 3, you are granted additional | |
# permissions described in the Autoconf Configure Script Exception, | |
# version 3.0, as published by the Free Software Foundation. | |
# | |
# You should have received a copy of the GNU General Public License | |
# and a copy of the Autoconf Configure Script Exception along with | |
# this program; see the files COPYINGv3 and COPYING.EXCEPTION | |
# respectively. If not, see <http://www.gnu.org/licenses/>. | |
# Written by Eric Blake. | |
# In M4 1.4.x, every byte of $@ is rescanned. This means that an | |
# algorithm on n arguments that recurses with one less argument each | |
# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In | |
# M4 1.6, this was fixed so that $@ is only scanned once, then | |
# back-references are made to information stored about the scan. | |
# Thus, n iterations need only scan n arguments, for O(n) time. | |
# Additionally, in M4 1.4.x, recursive algorithms did not clean up | |
# memory very well, requiring O(n^2) memory rather than O(n) for n | |
# iterations. | |
# | |
# This file is designed to overcome the quadratic nature of $@ | |
# recursion by writing a variant of m4_foreach that uses m4_for rather | |
# than $@ recursion to operate on the list. This involves more macro | |
# expansions, but avoids the need to rescan a quadratic number of | |
# arguments, making these replacements very attractive for M4 1.4.x. | |
# On the other hand, in any version of M4, expanding additional macros | |
# costs additional time; therefore, in M4 1.6, where $@ recursion uses | |
# fewer macros, these replacements actually pessimize performance. | |
# Additionally, the use of $10 to mean the tenth argument violates | |
# POSIX; although all versions of m4 1.4.x support this meaning, a | |
# future m4 version may switch to take it as the first argument | |
# concatenated with a literal 0, so the implementations in this file | |
# are not future-proof. Thus, this file is conditionally included as | |
# part of m4_init(), only when it is detected that M4 probably has | |
# quadratic behavior (ie. it lacks the macro __m4_version__). | |
# | |
# Please keep this file in sync with m4sugar.m4. | |
# _m4_foreach(PRE, POST, IGNORED, ARG...) | |
# --------------------------------------- | |
# Form the common basis of the m4_foreach and m4_map macros. For each | |
# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion | |
# easier, and must be supplied rather than implicit. | |
# | |
# This version minimizes the number of times that $@ is evaluated by | |
# using m4_for to generate a boilerplate into _m4_f then passing $@ to | |
# that temporary macro. Thus, the recursion is done in m4_for without | |
# reparsing any user input, and is not quadratic. For an idea of how | |
# this works, note that m4_foreach(i,[1,2],[i]) calls | |
# _m4_foreach([m4_define([i],],[)i],[],[1],[2]) | |
# which defines _m4_f: | |
# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f]) | |
# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result: | |
# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]). | |
m4_define([_m4_foreach], | |
[m4_if([$#], [3], [], | |
[m4_pushdef([_m4_f], _m4_for([4], [$#], [1], | |
[$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])]) | |
m4_define([_m4_foreach_], | |
[[$$1[$$3]$$2[]]]) | |
# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) | |
# ----------------------------------------------------------- | |
# Find the first VAL that SWITCH matches, and expand the corresponding | |
# IF-VAL. If there are no matches, expand DEFAULT. | |
# | |
# Use m4_for to create a temporary macro in terms of a boilerplate | |
# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is | |
# odd, then rounding the last $# up in the temporary macro is | |
# harmless. For example, both m4_case(1,2,3,4,5) and | |
# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being | |
# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) | |
m4_define([m4_case], | |
[m4_if(m4_eval([$# <= 2]), [1], [$2], | |
[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2], | |
[_$0_(], [)])[_m4_popdef( | |
[_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) | |
m4_define([_m4_case_], | |
[$0_([1], [$1], m4_incr([$1]))]) | |
m4_define([_m4_case__], | |
[[[$$1],[$$2],[$$3],]]) | |
# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) | |
# ----------------------------------------------------- | |
# m4 equivalent of | |
# | |
# if (SWITCH =~ RE1) | |
# VAL1; | |
# elif (SWITCH =~ RE2) | |
# VAL2; | |
# elif ... | |
# ... | |
# else | |
# DEFAULT | |
# | |
# We build the temporary macro _m4_b: | |
# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... | |
# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) | |
# then invoke m4_unquote(_m4_b($@)), for concatenation with later text. | |
m4_define([m4_bmatch], | |
[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], | |
[$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], | |
[$#], 2, [$2], | |
[m4_pushdef([_m4_b], [m4_define([_m4_b], | |
_m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]), | |
[2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval( | |
[($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) | |
m4_define([_m4_bmatch], | |
[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) | |
m4_define([_m4_bmatch_], | |
[$0_([1], m4_decr([$1]), [$1])]) | |
m4_define([_m4_bmatch__], | |
[[_m4_b([$$1], [$$2], [$$3])]]) | |
# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) | |
# ------------------------------------------------------------------- | |
# Similar to m4_if, except that each TEST is expanded when encountered. | |
# If the expansion of TESTn matches the string VALn, the result is IF-VALn. | |
# The result is DEFAULT if no tests passed. This macro allows | |
# short-circuiting of expensive tests, where it pays to arrange quick | |
# filter tests to run first. | |
# | |
# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. | |
# We only have to speed up _m4_cond, by building the temporary _m4_c: | |
# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], | |
# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], | |
# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], | |
# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) | |
# We invoke m4_unquote(_m4_c($@)), for concatenation with later text. | |
m4_define([_m4_cond], | |
[m4_pushdef([_m4_c], [m4_define([_m4_c], | |
_m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3], | |
[$0_(], [)])[_m4_c(]m4_dquote(m4_dquote( | |
[$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) | |
m4_define([_m4_cond_], | |
[$0_(m4_decr([$1]), [$1], m4_incr([$1]))]) | |
m4_define([_m4_cond__], | |
[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) | |
# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) | |
# ---------------------------------------------------- | |
# m4 equivalent of | |
# | |
# $_ = STRING; | |
# s/RE1/SUBST1/g; | |
# s/RE2/SUBST2/g; | |
# ... | |
# | |
# m4_bpatsubsts already validated an odd number of arguments; we only | |
# need to speed up _m4_bpatsubsts. To avoid nesting, we build the | |
# temporary _m4_p: | |
# m4_define([_m4_p], [$1])m4_define([_m4_p], | |
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], | |
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... | |
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( | |
# _m4_defn([_m4_p])_m4_popdef([_m4_p])) | |
m4_define([_m4_bpatsubsts], | |
[m4_pushdef([_m4_p], [m4_define([_m4_p], | |
]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(], | |
[)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) | |
m4_define([_m4_bpatsubsts_], | |
[$0_(m4_decr([$1]), [$1])]) | |
m4_define([_m4_bpatsubsts__], | |
[[m4_define([_m4_p], | |
m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) | |
# m4_shiftn(N, ...) | |
# ----------------- | |
# Returns ... shifted N times. Useful for recursive "varargs" constructs. | |
# | |
# m4_shiftn already validated arguments; we only need to speed up | |
# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as | |
# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) | |
# before calling m4_shift(_m4_s($@)). | |
m4_define([_m4_shiftn], | |
[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s], | |
_m4_for(m4_eval([$1 + 2]), [$#], [1], | |
[[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) | |
# m4_do(STRING, ...) | |
# ------------------ | |
# This macro invokes all its arguments (in sequence, of course). It is | |
# useful for making your macros more structured and readable by dropping | |
# unnecessary dnl's and have the macros indented properly. | |
# | |
# Here, we use the temporary macro _m4_do, defined as | |
# $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) | |
m4_define([m4_do], | |
[m4_if([$#], [0], [], | |
[m4_pushdef([_$0], _m4_for([1], [$#], [1], | |
[$], [[[]]])[_m4_popdef([_$0])])_$0($@)])]) | |
# m4_dquote_elt(ARGS) | |
# ------------------- | |
# Return ARGS as an unquoted list of double-quoted arguments. | |
# | |
# _m4_foreach to the rescue. | |
m4_define([m4_dquote_elt], | |
[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])]) | |
# m4_reverse(ARGS) | |
# ---------------- | |
# Output ARGS in reverse order. | |
# | |
# Invoke _m4_r($@) with the temporary _m4_r built as | |
# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) | |
m4_define([m4_reverse], | |
[m4_if([$#], [0], [], [$#], [1], [[$1]], | |
[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1], | |
[[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])]) | |
# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) | |
# ------------------------------------------------------------- | |
# Perform a pairwise grouping of consecutive ARGs, by expanding | |
# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the | |
# final argument is expanded with END-EXPR([ARGn]). | |
# | |
# Build the temporary macro _m4_map_args_pair, with the $2([$m+1]) | |
# only output if $# is odd: | |
# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], | |
# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair]) | |
m4_define([m4_map_args_pair], | |
[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], | |
[$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], | |
[$#], [2], [], | |
[$#], [3], [m4_default([$2], [$1])([$3])[]], | |
[m4_pushdef([_$0], _m4_for([3], | |
m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end( | |
[1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) | |
m4_define([_m4_map_args_pair_], | |
[$0_([1], [$1], m4_incr([$1]))]) | |
m4_define([_m4_map_args_pair__], | |
[[$$1([$$2], [$$3])[]]]) | |
m4_define([_m4_map_args_pair_end], | |
[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) | |
# m4_join(SEP, ARG1, ARG2...) | |
# --------------------------- | |
# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG | |
# is the empty string. No expansion is performed on SEP or ARGs. | |
# | |
# Use a self-modifying separator, since we don't know how many | |
# arguments might be skipped before a separator is first printed, but | |
# be careful if the separator contains $. _m4_foreach to the rescue. | |
m4_define([m4_join], | |
[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl | |
[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])]) | |
m4_define([_m4_join], | |
[m4_if([$2], [], [], [_m4_sep([$1])[$2]])]) | |
# m4_joinall(SEP, ARG1, ARG2...) | |
# ------------------------------ | |
# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. | |
# No expansion is performed on SEP or ARGs. | |
# | |
# A bit easier than m4_join. _m4_foreach to the rescue. | |
m4_define([m4_joinall], | |
[[$2]m4_if(m4_eval([$# <= 2]), [1], [], | |
[_m4_foreach([$1], [], m4_shift($@))])]) | |
# m4_list_cmp(A, B) | |
# ----------------- | |
# Compare the two lists of integer expressions A and B. | |
# | |
# m4_list_cmp takes care of any side effects; we only override | |
# _m4_list_cmp_raw, where we can safely expand lists multiple times. | |
# First, insert padding so that both lists are the same length; the | |
# trailing +0 is necessary to handle a missing list. Next, create a | |
# temporary macro to perform pairwise comparisons until an inequality | |
# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as | |
# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], | |
# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], | |
# [0]_m4_popdef([_m4_cmp])) | |
# then calls _m4_cmp([1+0], [0*2], [1], [2+0]) | |
m4_define([_m4_list_cmp_raw], | |
[m4_if([$1], [$2], 0, | |
[_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), | |
$2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) | |
m4_define([_m4_list_pad], | |
[m4_if(m4_eval($1 < $2), [1], | |
[_m4_for(m4_incr([$1]), [$2], [1], [,0*])])]) | |
m4_define([_m4_list_cmp], | |
[m4_pushdef([_m4_cmp], [m4_if(]_m4_for( | |
[1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[ | |
[0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)]) | |
m4_define([_m4_list_cmp_], | |
[$0_([$1], m4_eval([$1 + $2]))]) | |
m4_define([_m4_list_cmp__], | |
[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], | |
]]) | |
# m4_max(EXPR, ...) | |
# m4_min(EXPR, ...) | |
# ----------------- | |
# Return the decimal value of the maximum (or minimum) in a series of | |
# integer expressions. | |
# | |
# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here, | |
# we need a temporary macro to track the best answer so far, so that | |
# the foreach expression is tractable. | |
m4_define([_m4_minmax], | |
[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach( | |
[m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl | |
[_m4_best[]_m4_popdef([_m4_best])]) | |
# m4_set_add_all(SET, VALUE...) | |
# ----------------------------- | |
# Add each VALUE into SET. This is O(n) in the number of VALUEs, and | |
# can be faster than calling m4_set_add for each VALUE. | |
# | |
# _m4_foreach to the rescue. If no deletions have occurred, then | |
# avoid the speed penalty of m4_set_add. | |
m4_define([m4_set_add_all], | |
[m4_if([$#], [0], [], [$#], [1], [], | |
[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) | |
+ m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)], | |
[[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])]) | |
m4_define([_m4_set_add_all], | |
[m4_ifdef([_m4_set([$1],$2)], [], | |
[m4_define([_m4_set([$1],$2)], | |
[1])m4_pushdef([_m4_set([$1])], [$2])-])]) |