data/m4sugar/m4sugar.m4

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