Annotation of win32/tools/cygwin/usr/share/bison/m4sugar/foreach.m4, revision 1.1
1.1 ! misha 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]))-])]])))))])])
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to foreach.m4 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / tools / cygwin / usr / share / bison / m4sugar