OLD | NEW |
(Empty) | |
| 1 # -*- Autoconf -*- |
| 2 # This file is part of Autoconf. |
| 3 # foreach-based replacements for recursive functions. |
| 4 # Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes |
| 5 # GNU M4 1.6 by requiring more memory and macro expansions. |
| 6 # |
| 7 # Copyright (C) 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 Eric Blake. |
| 50 # |
| 51 |
| 52 # In M4 1.4.x, every byte of $@ is rescanned. This means that an |
| 53 # algorithm on n arguments that recurses with one less argument each |
| 54 # iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In |
| 55 # M4 1.6, this was fixed so that $@ is only scanned once, then |
| 56 # back-references are made to information stored about the scan. |
| 57 # Thus, n iterations need only scan n arguments, for O(n) time. |
| 58 # Additionally, in M4 1.4.x, recursive algorithms did not clean up |
| 59 # memory very well, requiring O(n^2) memory rather than O(n) for n |
| 60 # iterations. |
| 61 # |
| 62 # This file is designed to overcome the quadratic nature of $@ |
| 63 # recursion by writing a variant of m4_foreach that uses m4_for rather |
| 64 # than $@ recursion to operate on the list. This involves more macro |
| 65 # expansions, but avoids the need to rescan a quadratic number of |
| 66 # arguments, making these replacements very attractive for M4 1.4.x. |
| 67 # On the other hand, in any version of M4, expanding additional macros |
| 68 # costs additional time; therefore, in M4 1.6, where $@ recursion uses |
| 69 # fewer macros, these replacements actually pessimize performance. |
| 70 # Additionally, the use of $10 to mean the tenth argument violates |
| 71 # POSIX; although all versions of m4 1.4.x support this meaning, a |
| 72 # future m4 version may switch to take it as the first argument |
| 73 # concatenated with a literal 0, so the implementations in this file |
| 74 # are not future-proof. Thus, this file is conditionally included as |
| 75 # part of m4_init(), only when it is detected that M4 probably has |
| 76 # quadratic behavior (ie. it lacks the macro __m4_version__). |
| 77 # |
| 78 # Please keep this file in sync with m4sugar.m4. |
| 79 |
| 80 # m4_foreach(VARIABLE, LIST, EXPRESSION) |
| 81 # -------------------------------------- |
| 82 # Expand EXPRESSION assigning each value of the LIST to VARIABLE. |
| 83 # LIST should have the form `item_1, item_2, ..., item_n', i.e. the |
| 84 # whole list must *quoted*. Quote members too if you don't want them |
| 85 # to be expanded. |
| 86 # |
| 87 # This version minimizes the number of times that $@ is evaluated by |
| 88 # using m4_for to generate a boilerplate into VARIABLE then passing $@ |
| 89 # to that temporary macro. Thus, the recursion is done in m4_for |
| 90 # without reparsing any user input, and is not quadratic. For an idea |
| 91 # of how this works, note that m4_foreach(i,[1,2],[i]) defines i to be |
| 92 # m4_define([$1],[$3])$2[]m4_define([$1],[$4])$2[]m4_popdef([i]) |
| 93 # then calls i([i],[i],[1],[2]). |
| 94 m4_define([m4_foreach], |
| 95 [m4_if([$2], [], [], [_$0([$1], [$3], $2)])]) |
| 96 |
| 97 m4_define([_m4_foreach], |
| 98 [m4_define([$1], m4_pushdef([$1])_m4_for([$1], [3], [$#], [1], |
| 99 [$0_([1], [2], _m4_defn([$1]))])[m4_popdef([$1])])m4_indir([$1], $@)]) |
| 100 |
| 101 m4_define([_m4_foreach_], |
| 102 [[m4_define([$$1], [$$3])$$2[]]]) |
| 103 |
| 104 # m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) |
| 105 # ----------------------------------------------------------- |
| 106 # Find the first VAL that SWITCH matches, and expand the corresponding |
| 107 # IF-VAL. If there are no matches, expand DEFAULT. |
| 108 # |
| 109 # Use m4_for to create a temporary macro in terms of a boilerplate |
| 110 # m4_if with final cleanup. If $# is even, we have DEFAULT; if it is |
| 111 # odd, then rounding the last $# up in the temporary macro is |
| 112 # harmless. For example, both m4_case(1,2,3,4,5) and |
| 113 # m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being |
| 114 # m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) |
| 115 m4_define([m4_case], |
| 116 [m4_if(m4_eval([$# <= 2]), [1], [$2], |
| 117 [m4_pushdef([_$0], [m4_if(]m4_for([_m4_count], [2], m4_decr([$#]), [2], |
| 118 [_$0_([1], _m4_count, m4_incr(_m4_count))])[_m4_popdef( |
| 119 [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) |
| 120 |
| 121 m4_define([_m4_case_], |
| 122 [[[$$1],[$$2],[$$3],]]) |
| 123 |
| 124 # m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) |
| 125 # ----------------------------------------------------- |
| 126 # m4 equivalent of |
| 127 # |
| 128 # if (SWITCH =~ RE1) |
| 129 # VAL1; |
| 130 # elif (SWITCH =~ RE2) |
| 131 # VAL2; |
| 132 # elif ... |
| 133 # ... |
| 134 # else |
| 135 # DEFAULT |
| 136 # |
| 137 # We build the temporary macro _m4_b: |
| 138 # m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... |
| 139 # _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) |
| 140 # then invoke m4_unquote(_m4_b($@)), for concatenation with later text. |
| 141 m4_define([m4_bmatch], |
| 142 [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], |
| 143 [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], |
| 144 [$#], 2, [$2], |
| 145 [m4_define([_m4_b], m4_pushdef([_m4_b])[m4_define([_m4_b], |
| 146 _m4_defn([_$0]))]_m4_for([_m4_b], [3], m4_eval([($# + 1) / 2 * 2 - 1]), |
| 147 [2], [_$0_([1], m4_decr(_m4_b), _m4_b)])[_m4_b([], [],]m4_dquote( |
| 148 [$]m4_incr(_m4_b))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) |
| 149 |
| 150 m4_define([_m4_bmatch], |
| 151 [m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) |
| 152 |
| 153 m4_define([_m4_bmatch_], |
| 154 [[_m4_b([$$1], [$$2], [$$3])]]) |
| 155 |
| 156 |
| 157 # m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) |
| 158 # ------------------------------------------------------------------- |
| 159 # Similar to m4_if, except that each TEST is expanded when encountered. |
| 160 # If the expansion of TESTn matches the string VALn, the result is IF-VALn. |
| 161 # The result is DEFAULT if no tests passed. This macro allows |
| 162 # short-circuiting of expensive tests, where it pays to arrange quick |
| 163 # filter tests to run first. |
| 164 # |
| 165 # m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. |
| 166 # We only have to speed up _m4_cond, by building the temporary _m4_c: |
| 167 # m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], |
| 168 # [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], |
| 169 # [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], |
| 170 # [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) |
| 171 # We invoke m4_unquote(_m4_c($@)), for concatenation with later text. |
| 172 m4_define([_m4_cond], |
| 173 [m4_define([_m4_c], m4_pushdef([_m4_c])[m4_define([_m4_c], |
| 174 _m4_defn([m4_unquote]))]_m4_for([_m4_c], [2], m4_eval([$# / 3 * 3 - 1]), [3], |
| 175 [$0_(m4_decr(_m4_c), _m4_c, m4_incr(_m4_c))])[_m4_c(]m4_dquote(m4_dquote( |
| 176 [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) |
| 177 |
| 178 m4_define([_m4_cond_], |
| 179 [[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) |
| 180 |
| 181 # m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) |
| 182 # ---------------------------------------------------- |
| 183 # m4 equivalent of |
| 184 # |
| 185 # $_ = STRING; |
| 186 # s/RE1/SUBST1/g; |
| 187 # s/RE2/SUBST2/g; |
| 188 # ... |
| 189 # |
| 190 # m4_bpatsubsts already validated an odd number of arguments; we only |
| 191 # need to speed up _m4_bpatsubsts. To avoid nesting, we build the |
| 192 # temporary _m4_p: |
| 193 # m4_define([_m4_p], [$1])m4_define([_m4_p], |
| 194 # m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], |
| 195 # m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... |
| 196 # m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( |
| 197 # _m4_defn([_m4_p])_m4_popdef([_m4_p])) |
| 198 m4_define([_m4_bpatsubsts], |
| 199 [m4_define([_m4_p], m4_pushdef([_m4_p])[m4_define([_m4_p], |
| 200 ]m4_dquote([$]1)[)]_m4_for([_m4_p], [3], [$#], [2], [$0_(m4_decr(_m4_p), |
| 201 _m4_p)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) |
| 202 |
| 203 m4_define([_m4_bpatsubsts_], |
| 204 [[m4_define([_m4_p], |
| 205 m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) |
| 206 |
| 207 # m4_shiftn(N, ...) |
| 208 # ----------------- |
| 209 # Returns ... shifted N times. Useful for recursive "varargs" constructs. |
| 210 # |
| 211 # m4_shiftn already validated arguments; we only need to speed up |
| 212 # _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as |
| 213 # ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) |
| 214 # before calling m4_shift(_m4_s($@)). |
| 215 m4_define([_m4_shiftn], |
| 216 [m4_if(m4_incr([$1]), [$#], [], [m4_define([_m4_s], |
| 217 m4_pushdef([_m4_s])_m4_for([_m4_s], m4_eval([$1 + 2]), [$#], [1], |
| 218 [[,]m4_dquote([$]_m4_s)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) |
| 219 |
| 220 # m4_do(STRING, ...) |
| 221 # ------------------ |
| 222 # This macro invokes all its arguments (in sequence, of course). It is |
| 223 # useful for making your macros more structured and readable by dropping |
| 224 # unnecessary dnl's and have the macros indented properly. |
| 225 # |
| 226 # Here, we use the temporary macro _m4_do, defined as |
| 227 # $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) |
| 228 m4_define([m4_do], |
| 229 [m4_if([$#], [0], [], |
| 230 [m4_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [1], [$#], [1], |
| 231 [$_$0[[]]])[_m4_popdef([_$0])])_$0($@)])]) |
| 232 |
| 233 # m4_dquote_elt(ARGS) |
| 234 # ------------------- |
| 235 # Return ARGS as an unquoted list of double-quoted arguments. |
| 236 # |
| 237 # m4_foreach to the rescue. It's easier to shift off the leading comma. |
| 238 m4_define([m4_dquote_elt], |
| 239 [m4_shift(m4_foreach([_m4_elt], [$@], [,m4_dquote(_m4_defn([_m4_elt]))]))]) |
| 240 |
| 241 # m4_reverse(ARGS) |
| 242 # ---------------- |
| 243 # Output ARGS in reverse order. |
| 244 # |
| 245 # Invoke _m4_r($@) with the temporary _m4_r built as |
| 246 # [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) |
| 247 m4_define([m4_reverse], |
| 248 [m4_if([$#], [0], [], [$#], [1], [[$1]], |
| 249 [m4_define([_m4_r], m4_dquote([$$#])m4_pushdef([_m4_r])_m4_for([_m4_r], |
| 250 m4_decr([$#]), [1], [-1], |
| 251 [[, ]m4_dquote([$]_m4_r)])[_m4_popdef([_m4_r])])_m4_r($@)])]) |
| 252 |
| 253 |
| 254 # m4_map(MACRO, LIST) |
| 255 # ------------------- |
| 256 # Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements |
| 257 # of LIST. $1, $2... must in turn be lists, appropriate for m4_apply. |
| 258 # |
| 259 # m4_map/m4_map_sep only execute once; the speedup comes in fixing |
| 260 # _m4_map. The mismatch in () is intentional, since $1 supplies the |
| 261 # opening `(' (but it sure looks odd!). Build the temporary _m4_m: |
| 262 # $1, [$3])$1, [$4])...$1, [$m])_m4_popdef([_m4_m]) |
| 263 m4_define([_m4_map], |
| 264 [m4_if([$#], [2], [], |
| 265 [m4_define([_m4_m], m4_pushdef([_m4_m])_m4_for([_m4_m], [3], [$#], [1], |
| 266 [$0_([1], _m4_m)])[_m4_popdef([_m4_m])])_m4_m($@)])]) |
| 267 |
| 268 m4_define([_m4_map_], |
| 269 [[$$1, [$$2])]]) |
| 270 |
| 271 # m4_transform(EXPRESSION, ARG...) |
| 272 # -------------------------------- |
| 273 # Expand EXPRESSION([ARG]) for each argument. More efficient than |
| 274 # m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) |
| 275 # |
| 276 # Invoke the temporary macro _m4_transform, defined as: |
| 277 # $1([$2])[]$1([$3])[]...$1([$m])[]_m4_popdef([_m4_transform]) |
| 278 m4_define([m4_transform], |
| 279 [m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], |
| 280 [$#], [1], [], |
| 281 [m4_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [2], [$#], [1], |
| 282 [_$0_([1], _$0)])[_m4_popdef([_$0])])_$0($@)])]) |
| 283 |
| 284 m4_define([_m4_transform_], |
| 285 [[$$1([$$2])[]]]) |
| 286 |
| 287 # m4_transform_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) |
| 288 # -------------------------------------------------------------- |
| 289 # Perform a pairwise grouping of consecutive ARGs, by expanding |
| 290 # EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the |
| 291 # final argument is expanded with END-EXPR([ARGn]). |
| 292 # |
| 293 # Build the temporary macro _m4_transform_pair, with the $2([$m+1]) |
| 294 # only output if $# is odd: |
| 295 # $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], |
| 296 # [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_transform_pair]) |
| 297 m4_define([m4_transform_pair], |
| 298 [m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], |
| 299 [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], |
| 300 [$#], [2], [], |
| 301 [$#], [3], [m4_default([$2], [$1])([$3])[]], |
| 302 [m4_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [3], |
| 303 m4_eval([$# / 2 * 2 - 1]), [2], [_$0_([1], _$0, m4_incr(_$0))])_$0_end( |
| 304 [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) |
| 305 |
| 306 m4_define([_m4_transform_pair_], |
| 307 [[$$1([$$2], [$$3])[]]]) |
| 308 |
| 309 m4_define([_m4_transform_pair_end], |
| 310 [m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) |
| 311 |
| 312 # m4_join(SEP, ARG1, ARG2...) |
| 313 # --------------------------- |
| 314 # Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG |
| 315 # is the empty string. No expansion is performed on SEP or ARGs. |
| 316 # |
| 317 # Use a self-modifying separator, since we don't know how many |
| 318 # arguments might be skipped before a separator is first printed, but |
| 319 # be careful if the separator contains $. m4_foreach to the rescue. |
| 320 m4_define([m4_join], |
| 321 [m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl |
| 322 [m4_foreach([_m4_arg], [m4_shift($@)], |
| 323 [m4_ifset([_m4_arg], [_m4_sep([$1])_m4_defn([_m4_arg])])])]dnl |
| 324 [_m4_popdef([_m4_sep])]) |
| 325 |
| 326 # m4_joinall(SEP, ARG1, ARG2...) |
| 327 # ------------------------------ |
| 328 # Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. |
| 329 # No expansion is performed on SEP or ARGs. |
| 330 # |
| 331 # A bit easier than m4_join. m4_foreach to the rescue. |
| 332 m4_define([m4_joinall], |
| 333 [[$2]m4_if(m4_eval([$# <= 2]), [1], [], |
| 334 [m4_foreach([_m4_arg], [m4_shift2($@)], |
| 335 [[$1]_m4_defn([_m4_arg])])])]) |
| 336 |
| 337 # m4_list_cmp(A, B) |
| 338 # ----------------- |
| 339 # Compare the two lists of integer expressions A and B. |
| 340 # |
| 341 # m4_list_cmp takes care of any side effects; we only override |
| 342 # _m4_list_cmp_raw, where we can safely expand lists multiple times. |
| 343 # First, insert padding so that both lists are the same length; the |
| 344 # trailing +0 is necessary to handle a missing list. Next, create a |
| 345 # temporary macro to perform pairwise comparisons until an inequality |
| 346 # is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as |
| 347 # m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], |
| 348 # m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], |
| 349 # [0]_m4_popdef([_m4_cmp], [_m4_size])) |
| 350 # then calls _m4_cmp([1+0], [0], [1], [2+0]) |
| 351 m4_define([_m4_list_cmp_raw], |
| 352 [m4_if([$1], [$2], 0, [m4_pushdef( |
| 353 [_m4_size])_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), |
| 354 $2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) |
| 355 |
| 356 m4_define([_m4_list_pad], |
| 357 [m4_if(m4_eval($1 < $2), [1], |
| 358 [_m4_for([_m4_size], m4_incr([$1]), [$2], [1], [,0])])]) |
| 359 |
| 360 m4_define([_m4_list_cmp], |
| 361 [m4_define([_m4_size], m4_eval([$# >> 1]))]dnl |
| 362 [m4_define([_m4_cmp], m4_pushdef([_m4_cmp])[m4_if(]_m4_for([_m4_cmp], |
| 363 [1], _m4_size, [1], [$0_(_m4_cmp, m4_eval(_m4_cmp + _m4_size))])[ |
| 364 [0]_m4_popdef([_m4_cmp], [_m4_size]))])_m4_cmp($@)]) |
| 365 |
| 366 m4_define([_m4_list_cmp_], |
| 367 [[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], |
| 368 ]]) |
| 369 |
| 370 # m4_max(EXPR, ...) |
| 371 # m4_min(EXPR, ...) |
| 372 # ----------------- |
| 373 # Return the decimal value of the maximum (or minimum) in a series of |
| 374 # integer expressions. |
| 375 # |
| 376 # m4_foreach to the rescue; we only need to replace _m4_minmax. Here, |
| 377 # we need a temporary macro to track the best answer so far, so that |
| 378 # the foreach expression is tractable. |
| 379 m4_define([_m4_minmax], |
| 380 [m4_pushdef([_m4_best], m4_eval([$2]))m4_foreach([_m4_arg], [m4_shift2($@)], |
| 381 [m4_define([_m4_best], $1(_m4_best, _m4_defn([_m4_arg])))])]dnl |
| 382 [_m4_best[]_m4_popdef([_m4_best])]) |
| 383 |
| 384 # m4_set_add_all(SET, VALUE...) |
| 385 # ----------------------------- |
| 386 # Add each VALUE into SET. This is O(n) in the number of VALUEs, and |
| 387 # can be faster than calling m4_set_add for each VALUE. |
| 388 # |
| 389 # m4_foreach to the rescue. If no deletions have occurred, then avoid |
| 390 # the speed penalty of m4_set_add. |
| 391 m4_define([m4_set_add_all], |
| 392 [m4_if([$#], [0], [], [$#], [1], [], |
| 393 [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) |
| 394 + m4_len(m4_foreach([_m4_arg], [m4_shift($@)], |
| 395 m4_ifdef([_m4_set_cleanup($1)], |
| 396 [[m4_set_add([$1], _m4_defn([_m4_arg]))]], |
| 397 [[m4_ifdef([_m4_set([$1],]_m4_defn([_m4_arg])[)], [], |
| 398 [m4_define([_m4_set([$1],]_m4_defn([_m4_arg])[)], |
| 399 [1])m4_pushdef([_m4_set([$1])], |
| 400 _m4_defn([_m4_arg]))-])]])))))])]) |
OLD | NEW |