[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[SCM] GNU M4 source repository branch, branch-1.6, updated. v1.5.89a-148
|
From: |
Eric Blake |
|
Subject: |
[SCM] GNU M4 source repository branch, branch-1.6, updated. v1.5.89a-148-gda026e3 |
|
Date: |
Wed, 30 Dec 2009 05:23:31 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU M4 source repository".
http://git.sv.gnu.org/gitweb/?p=m4.git;a=commitdiff;h=da026e34279bffd8f29ff5325628a74fe80c5d0b
The branch, branch-1.6 has been updated
via da026e34279bffd8f29ff5325628a74fe80c5d0b (commit)
via 4be31e21914c72c60847307b979dfffcda620862 (commit)
via e8fe0954e6529b225fe58a42d1751fcb27e2df50 (commit)
from 58a08cc51756129f0abde91e3917d7cb22413e49 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit da026e34279bffd8f29ff5325628a74fe80c5d0b
Author: Eric Blake <address@hidden>
Date: Mon Dec 14 15:23:14 2009 -0700
Document new indentation policy.
* HACKING: Document indentation policy.
* .x-sc_prohibit_tab_based_indentation: New file.
* cfg.mk (sc_prohibit_tab_based_indentation): New rule.
* Makefile.am (syntax_check_exceptions): New macro.
(EXTRA_DIST): Distribute exception files, and .prev-version.
Signed-off-by: Eric Blake <address@hidden>
(cherry picked from commit a8cef71593e876b027733fdb0137ed1655cae584)
commit 4be31e21914c72c60847307b979dfffcda620862
Author: Eric Blake <address@hidden>
Date: Mon Dec 14 13:52:15 2009 -0700
Switch to indentation by space, not tab.
Now that gnulib has converted and git has better support for
ignoring whitespace differences across this commit, we might as
well be consistent with other GNU projects.
Done with:
t=$'\t'
git ls-files \
| grep -vE '(^|/)(.*akefile|ChangeLog|HACKING|.*-aux/.*)|\.(am|mk)$' \
| xargs grep -lE "^ *$t" \
| xargs perl -MText::Tabs -ni -le \
'$m=/^( *\t[ \t]*)(.*)/; print $m ? expand($1) . $2 : $_'
* .gitmodules: Convert leading tabs to spaces.
* TODO: Likewise.
* bootstrap: Likewise.
* c-boxes.el: Likewise.
* checks/check-them: Likewise.
* checks/get-them: Likewise.
* examples/stackovf.sh: Likewise.
* configure.ac: Likewise.
* src/builtin.c: Likewise.
* src/debug.c: Likewise.
* src/eval.c: Likewise.
* src/format.c: Likewise.
* src/freeze.c: Likewise.
* src/input.c: Likewise.
* src/m4.c: Likewise.
* src/m4.h: Likewise.
* src/macro.c: Likewise.
* src/output.c: Likewise.
* src/path.c: Likewise.
* src/stackovf.c: Likewise.
* src/symtab.c: Likewise.
Signed-off-by: Eric Blake <address@hidden>
(cherry picked from commit 180b7d19bf95d2abb21bca587a0684eca69679ad)
commit e8fe0954e6529b225fe58a42d1751fcb27e2df50
Author: Eric Blake <address@hidden>
Date: Mon Dec 14 13:32:29 2009 -0700
Update to latest gnulib.
* gnulib: Update.
* m4/gnulib-cache.m4: Import xoset.
* src/output.c (includes): Ensure that gnulib oset usage will
call xalloc_die on memory failure.
Signed-off-by: Eric Blake <address@hidden>
(cherry picked from commit 43b9828d5bfe5c9be902ad86053e59f3a5ab2dd4)
-----------------------------------------------------------------------
Summary of changes:
.gitmodules | 4 +-
.x-sc_prohibit_tab_based_indentation | 5 +
ChangeLog | 38 +
HACKING | 32 +-
Makefile.am | 7 +-
TODO | 26 +-
bootstrap | 26 +-
c-boxes.el | 440 ++++++------
cfg.mk | 6 +
checks/check-them | 2 +-
checks/get-them | 20 +-
configure.ac | 18 +-
examples/stackovf.sh | 48 +-
gnulib | 2 +-
m4/gnulib-cache.m4 | 3 +-
src/builtin.c | 966 ++++++++++++------------
src/debug.c | 170 ++--
src/eval.c | 482 ++++++------
src/format.c | 364 +++++-----
src/freeze.c | 304 ++++----
src/input.c | 1414 +++++++++++++++++-----------------
src/m4.c | 304 ++++----
src/m4.h | 110 ++--
src/macro.c | 1030 +++++++++++++-------------
src/output.c | 487 ++++++------
src/path.c | 42 +-
src/stackovf.c | 110 ++--
src/symtab.c | 280 ++++----
28 files changed, 3411 insertions(+), 3329 deletions(-)
create mode 100644 .x-sc_prohibit_tab_based_indentation
diff --git a/.gitmodules b/.gitmodules
index acb2669..bb9e1ba 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
[submodule "gnulib"]
- path = gnulib
- url = git://git.sv.gnu.org/gnulib.git
+ path = gnulib
+ url = git://git.sv.gnu.org/gnulib.git
diff --git a/.x-sc_prohibit_tab_based_indentation
b/.x-sc_prohibit_tab_based_indentation
new file mode 100644
index 0000000..bd9127e
--- /dev/null
+++ b/.x-sc_prohibit_tab_based_indentation
@@ -0,0 +1,5 @@
+^GNUMakefile$
+Makefile\.am$
+\.mk$
+^HACKING$
+ChangeLog.*
diff --git a/ChangeLog b/ChangeLog
index 1623af7..aa2a36c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,41 @@
+2009-12-29 Eric Blake <address@hidden>
+
+ Document new indentation policy.
+ * HACKING: Document indentation policy.
+ * .x-sc_prohibit_tab_based_indentation: New file.
+ * cfg.mk (sc_prohibit_tab_based_indentation): New rule.
+ * Makefile.am (syntax_check_exceptions): New macro.
+ (EXTRA_DIST): Distribute exception files, and .prev-version.
+
+ Switch to indentation by space, not tab.
+ * .gitmodules: Convert leading tabs to spaces.
+ * TODO: Likewise.
+ * bootstrap: Likewise.
+ * c-boxes.el: Likewise.
+ * checks/check-them: Likewise.
+ * checks/get-them: Likewise.
+ * examples/stackovf.sh: Likewise.
+ * configure.ac: Likewise.
+ * src/builtin.c: Likewise.
+ * src/debug.c: Likewise.
+ * src/eval.c: Likewise.
+ * src/format.c: Likewise.
+ * src/freeze.c: Likewise.
+ * src/input.c: Likewise.
+ * src/m4.c: Likewise.
+ * src/m4.h: Likewise.
+ * src/macro.c: Likewise.
+ * src/output.c: Likewise.
+ * src/path.c: Likewise.
+ * src/stackovf.c: Likewise.
+ * src/symtab.c: Likewise.
+
+ Update to latest gnulib.
+ * gnulib: Update.
+ * m4/gnulib-cache.m4: Import xoset.
+ * src/output.c (includes): Ensure that gnulib oset usage will
+ call xalloc_die on memory failure.
+
2009-11-28 Eric Blake <address@hidden>
Work around BSD getopt bug.
diff --git a/HACKING b/HACKING
index 65f1924..c9ab48e 100644
--- a/HACKING
+++ b/HACKING
@@ -181,8 +181,34 @@ yyyy-mm-dd Name of Author <address@hidden> (tiny change)
* See the GNU Coding Standards document for more details on ChangeLog
formatting.
+6. Formatting
+=============
+
+* Use space-only indentation in nearly all files (Makefile and
+ ChangeLogs being the exception).
+
+ If you use Emacs and your m4 working directory name matches,
+ this code in your ~/.emacs enables the right mode:
+
+ ;; In m4, indent with spaces everywhere (not TABs).
+ ;; Exceptions: Makefile and ChangeLog modes.
+ (add-hook 'find-file-hook '(lambda ()
+ (if (and buffer-file-name
+ (string-match "/m4\\>" (buffer-file-name))
+ (not (string-equal mode-name "Change Log"))
+ (not (string-equal mode-name "Makefile")))
+ (setq indent-tabs-mode nil))))
+
+* Since the source code was massively converted from tabs in December
+ 2009, you may find it helpful to use 'git diff -w' and 'git blame -w'
+ helpful for overlooking the whitespace changes.
+
+* Avoid #ifdefs inside function bodies, whenever possible. If you
+ encounter a portability issue, it is better to propose a gnulib module
+ that works around it, and have m4 use that module.
+
-6. Release Procedure
+7. Release Procedure
====================
* If you are an m4 maintainer, but have not yet registered your
@@ -194,8 +220,8 @@ yyyy-mm-dd Name of Author <address@hidden> (tiny change)
preferred email address.
(b) an ASCII armored copy of your GnuPG key, as an attachment.
- ("gpg --export -a YOUR_KEY_ID > mykey.asc" should give you
- this.)
+ ("gpg --export -a YOUR_KEY_ID > mykey.asc" should give you
+ this.)
When you have received acknowledgement of your message, the proper GPG
keys will be registered on ftp-upload.gnu.org and only then will you be
diff --git a/Makefile.am b/Makefile.am
index 875750f..1d50592 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -21,8 +21,13 @@
## Written by Gary V. Vaughan <address@hidden>
SUBDIRS = . examples lib src doc checks tests
+
+syntax_check_exceptions = \
+ .x-sc_prohibit_tab_based_indentation \
+ .x-update-copyright
+
EXTRA_DIST = bootstrap c-boxes.el cfg.mk maint.mk \
- .version m4/gnulib-cache.m4
+ .prev-version .version m4/gnulib-cache.m4 $(syntax_check_exceptions)
DISTCLEANFILES = stamp-h
## maintainer-clean should remove as much as possible that ./bootstrap can
## recreate. In the m4 directory, keep only gnulib-cache.m4.
diff --git a/TODO b/TODO
index 4151f5b..134f4c3 100644
--- a/TODO
+++ b/TODO
@@ -10,27 +10,27 @@ of these ideas, listed more or less in decreasing order of
priority.
- Update documentation from accumulated mail about it
- Study synclines at the very beginning of each diverted sequence
- Make eval work on bignums - the 32 bits limit is artificial
- From Krste Asanovic <address@hidden>, 1993-03-20
+ From Krste Asanovic <address@hidden>, 1993-03-20
* Optimization and clean up
- Check for memory leaks and uninitialized reads
- From Vern Paxson <address@hidden> on 1993-12-06
+ From Vern Paxson <address@hidden> on 1993-12-06
- Profile GNU m4 and speed it up
- From David J. MacKenzie <address@hidden>, 1993-01-20
+ From David J. MacKenzie <address@hidden>, 1993-01-20
- GNU m4 should be sped up by a factor of three for competing
- with other versions (I think that the lexer is not agressive
- enough and too often return single characters; obstacks might
- be a little abused, too).
+ GNU m4 should be sped up by a factor of three for competing
+ with other versions (I think that the lexer is not agressive
+ enough and too often return single characters; obstacks might
+ be a little abused, too).
- Have NULs go really undisturbed through GNU m4
- See `dumpdef' and debugging section, which abuses %s
- From Thorsten Ohl <address@hidden>, 1992-12-21
+ See `dumpdef' and debugging section, which abuses %s
+ From Thorsten Ohl <address@hidden>, 1992-12-21
- path.c (add_include_directory): Why the '\0' terminator?
+ path.c (add_include_directory): Why the '\0' terminator?
- GNU m4 is lousy regarding NULs in streams (this would require
- maintaining the string lengths, and avoiding strlen, strcpy,
- etc.).
+ GNU m4 is lousy regarding NULs in streams (this would require
+ maintaining the string lengths, and avoiding strlen, strcpy,
+ etc.).
Local Variables:
mode: outline
diff --git a/bootstrap b/bootstrap
index 81b87e3..7addfd3 100755
--- a/bootstrap
+++ b/bootstrap
@@ -1,6 +1,6 @@
#! /bin/sh
-# bootstrap (GNU M4) version 2009-05-14
+# bootstrap (GNU M4) version 2009-12-14
# Written by Gary V. Vaughan <address@hidden>
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software
@@ -128,9 +128,9 @@ func_missing_arg ()
func_usage ()
{
$SED '/^# Usage:/,/# -h/ {
- s/^# //; s/^# *$//;
- s/\$progname/'$progname'/;
- p;
+ s/^# //; s/^# *$//;
+ s/\$progname/'$progname'/;
+ p;
}; d' < "$progpath"
echo
echo "run \`$progname --help | more' for full usage"
@@ -142,9 +142,9 @@ func_usage ()
func_help ()
{
$SED '/^# Usage:/,/# Report bugs to/ {
- s/^# //; s/^# *$//;
- s/\$progname/'$progname'/;
- p;
+ s/^# //; s/^# *$//;
+ s/\$progname/'$progname'/;
+ p;
}; d' < "$progpath"
exit $EXIT_SUCCESS
}
@@ -154,9 +154,9 @@ func_help ()
func_version ()
{
$SED '/^# '$PROGRAM' (GNU /,/# warranty; / {
- s/^# //; s/^# *$//;
- s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/;
- p;
+ s/^# //; s/^# *$//;
+ s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/;
+ p;
}; d' < "$progpath"
exit $EXIT_SUCCESS
}
@@ -248,11 +248,11 @@ if test -d .git && (git --version) >/dev/null 2>/dev/null
; then
if test -d "$GNULIB_SRCDIR" ; then
rmdir gnulib 2>/dev/null
git clone --reference "$GNULIB_SRCDIR" git://git.sv.gnu.org/gnulib.git \
- && git submodule init && git submodule update \
- || func_fatal_error "Unable to update gnulib"
+ && git submodule init && git submodule update \
+ || func_fatal_error "Unable to update gnulib"
else
git submodule update --init \
- || func_fatal_error "Unable to update gnulib"
+ || func_fatal_error "Unable to update gnulib"
fi
fi
else
diff --git a/c-boxes.el b/c-boxes.el
index 5254e96..0dcd1fc 100644
--- a/c-boxes.el
+++ b/c-boxes.el
@@ -65,15 +65,15 @@
(if c-mode-taarna-style
(progn
- (setq c-mode-taarna-style nil)
- (setq c-indent-level 2)
- (setq c-continued-statement-offset 2)
- (setq c-brace-offset 0)
- (setq c-argdecl-indent 5)
- (setq c-label-offset -2)
- (setq c-tab-always-indent t)
- (setq c-box-default-style 'single)
- (message "C mode: GNU style"))
+ (setq c-mode-taarna-style nil)
+ (setq c-indent-level 2)
+ (setq c-continued-statement-offset 2)
+ (setq c-brace-offset 0)
+ (setq c-argdecl-indent 5)
+ (setq c-label-offset -2)
+ (setq c-tab-always-indent t)
+ (setq c-box-default-style 'single)
+ (message "C mode: GNU style"))
(setq c-mode-taarna-style t)
(setq c-indent-level 4)
@@ -94,10 +94,10 @@
(while (not (eobp))
(skip-chars-forward " \t")
(if (not (looking-at "\n"))
- (setq margin
- (if (< margin 0)
- (current-column)
- (min margin (current-column)))))
+ (setq margin
+ (if (< margin 0)
+ (current-column)
+ (min margin (current-column)))))
(forward-line 1))
margin))
@@ -110,10 +110,10 @@
(while (not (eobp))
(end-of-line)
(if (bobp)
- (setq period 0)
- (backward-char 1)
- (setq period (if (looking-at "[.?!]") 1 0))
- (forward-char 1))
+ (setq period 0)
+ (backward-char 1)
+ (setq period (if (looking-at "[.?!]") 1 0))
+ (forward-char 1))
(setq margin (max margin (+ (current-column) period)))
(forward-char 1))
margin))
@@ -130,9 +130,9 @@
(defun rebox-c-comment-engine (flag refill)
(save-restriction
(let ((undo-list buffer-undo-list)
- (marked-point (point-marker))
- (saved-point (point))
- box-style left-margin right-margin)
+ (marked-point (point-marker))
+ (saved-point (point))
+ box-style left-margin right-margin)
;; First, find the limits of the block of comments following or
;; enclosing the cursor, or return an error if the cursor is not
@@ -143,57 +143,57 @@
(skip-chars-forward " \t\n")
(if (looking-at "/\\*")
- (forward-char 2))
+ (forward-char 2))
(let ((here (point)) start end temp)
- ;; - identify a minimal comment block
-
- (search-backward "/*")
- (setq temp (point))
- (beginning-of-line)
- (setq start (point))
- (skip-chars-forward " \t")
- (if (< (point) temp)
- (progn
- (goto-char saved-point)
- (error "text before comment's start")))
- (search-forward "*/")
- (setq temp (point))
- (end-of-line)
- (if (looking-at "\n")
- (forward-char 1))
- (setq end (point))
- (skip-chars-backward " \t\n")
- (if (> (point) temp)
- (progn
- (goto-char saved-point)
- (error "text after comment's end")))
- (if (< end here)
- (progn
- (goto-char saved-point)
- (error "outside any comment block")))
-
- ;; - try to extend the comment block backwards
-
- (goto-char start)
- (while (and (not (bobp))
- (progn (previous-line 1)
- (beginning-of-line)
- (looking-at "[ \t]*/\\*.*\\*/[ \t]*$")))
- (setq start (point)))
-
- ;; - try to extend the comment block forward
-
- (goto-char end)
- (while (looking-at "[ \t]*/\\*.*\\*/[ \t]*$")
- (forward-line 1)
- (beginning-of-line)
- (setq end (point)))
-
- ;; - narrow to the whole block of comments
-
- (narrow-to-region start end))
+ ;; - identify a minimal comment block
+
+ (search-backward "/*")
+ (setq temp (point))
+ (beginning-of-line)
+ (setq start (point))
+ (skip-chars-forward " \t")
+ (if (< (point) temp)
+ (progn
+ (goto-char saved-point)
+ (error "text before comment's start")))
+ (search-forward "*/")
+ (setq temp (point))
+ (end-of-line)
+ (if (looking-at "\n")
+ (forward-char 1))
+ (setq end (point))
+ (skip-chars-backward " \t\n")
+ (if (> (point) temp)
+ (progn
+ (goto-char saved-point)
+ (error "text after comment's end")))
+ (if (< end here)
+ (progn
+ (goto-char saved-point)
+ (error "outside any comment block")))
+
+ ;; - try to extend the comment block backwards
+
+ (goto-char start)
+ (while (and (not (bobp))
+ (progn (previous-line 1)
+ (beginning-of-line)
+ (looking-at "[ \t]*/\\*.*\\*/[ \t]*$")))
+ (setq start (point)))
+
+ ;; - try to extend the comment block forward
+
+ (goto-char end)
+ (while (looking-at "[ \t]*/\\*.*\\*/[ \t]*$")
+ (forward-line 1)
+ (beginning-of-line)
+ (setq end (point)))
+
+ ;; - narrow to the whole block of comments
+
+ (narrow-to-region start end))
;; Second, remove all the comment marks, and move all the text
;; rigidly to the left to insure the left margin stays at the
@@ -201,60 +201,60 @@
;; style in BOX-STYLE.
(let ((previous-margin (buffer-left-margin))
- actual-margin)
-
- ;; - remove all comment marks
-
- (goto-char (point-min))
- (replace-regexp "^\\([ \t]*\\)/\\*" "\\1 ")
- (goto-char (point-min))
- (replace-regexp "^\\([ \t]*\\)|" "\\1 ")
- (goto-char (point-min))
- (replace-regexp "\\(\\*/\\||\\)[ \t]*" "")
- (goto-char (point-min))
- (replace-regexp "\\*/[ \t]*/\\*" " ")
-
- ;; - remove the first and last dashed lines
-
- (setq box-style 'plain)
- (goto-char (point-min))
- (if (looking-at "^[ \t]*-*[.\+\\]?[ \t]*\n")
- (progn
- (setq box-style 'single)
- (replace-match ""))
- (if (looking-at "^[ \t]*=*[.\+\\]?[ \t]*\n")
- (progn
- (setq box-style 'double)
- (replace-match ""))))
- (goto-char (point-max))
- (previous-line 1)
- (beginning-of-line)
- (if (looking-at "^[ \t]*[`\+\\]?*[-=]+[ \t]*\n")
- (progn
- (if (eq box-style 'plain)
- (setq box-style 'taarna))
- (replace-match "")))
-
- ;; - remove all spurious whitespace
-
- (goto-char (point-min))
- (replace-regexp "[ \t]+$" "")
- (goto-char (point-min))
- (if (looking-at "\n+")
- (replace-match ""))
- (goto-char (point-max))
- (skip-chars-backward "\n")
- (if (looking-at "\n\n+")
- (replace-match "\n"))
- (goto-char (point-min))
- (replace-regexp "\n\n\n+" "\n\n")
-
- ;; - move the text left is adequate
-
- (setq actual-margin (buffer-left-margin))
- (if (not (= previous-margin actual-margin))
- (indent-rigidly (point-min) (point-max)
- (- previous-margin actual-margin))))
+ actual-margin)
+
+ ;; - remove all comment marks
+
+ (goto-char (point-min))
+ (replace-regexp "^\\([ \t]*\\)/\\*" "\\1 ")
+ (goto-char (point-min))
+ (replace-regexp "^\\([ \t]*\\)|" "\\1 ")
+ (goto-char (point-min))
+ (replace-regexp "\\(\\*/\\||\\)[ \t]*" "")
+ (goto-char (point-min))
+ (replace-regexp "\\*/[ \t]*/\\*" " ")
+
+ ;; - remove the first and last dashed lines
+
+ (setq box-style 'plain)
+ (goto-char (point-min))
+ (if (looking-at "^[ \t]*-*[.\+\\]?[ \t]*\n")
+ (progn
+ (setq box-style 'single)
+ (replace-match ""))
+ (if (looking-at "^[ \t]*=*[.\+\\]?[ \t]*\n")
+ (progn
+ (setq box-style 'double)
+ (replace-match ""))))
+ (goto-char (point-max))
+ (previous-line 1)
+ (beginning-of-line)
+ (if (looking-at "^[ \t]*[`\+\\]?*[-=]+[ \t]*\n")
+ (progn
+ (if (eq box-style 'plain)
+ (setq box-style 'taarna))
+ (replace-match "")))
+
+ ;; - remove all spurious whitespace
+
+ (goto-char (point-min))
+ (replace-regexp "[ \t]+$" "")
+ (goto-char (point-min))
+ (if (looking-at "\n+")
+ (replace-match ""))
+ (goto-char (point-max))
+ (skip-chars-backward "\n")
+ (if (looking-at "\n\n+")
+ (replace-match "\n"))
+ (goto-char (point-min))
+ (replace-regexp "\n\n\n+" "\n\n")
+
+ ;; - move the text left is adequate
+
+ (setq actual-margin (buffer-left-margin))
+ (if (not (= previous-margin actual-margin))
+ (indent-rigidly (point-min) (point-max)
+ (- previous-margin actual-margin))))
;; Third, select the new box style from the old box style and
;; the argument, choose the margins for this style and refill
@@ -263,16 +263,16 @@
;; - modify box-style only if flag is defined
(if flag
- (setq box-style
- (cond ((eq flag 0) 'plain)
- ((eq flag 1) 'single)
- ((eq flag 2) 'double)
- ((eq flag 3) 'taarna)
- ((eq flag '-) (setq c-box-default-style 'plain) 'plain)
- ((eq flag -1) (setq c-box-default-style 'single) 'single)
- ((eq flag -2) (setq c-box-default-style 'double) 'double)
- ((eq flag -3) (setq c-box-default-style 'taarna) 'taarna)
- (t c-box-default-style))))
+ (setq box-style
+ (cond ((eq flag 0) 'plain)
+ ((eq flag 1) 'single)
+ ((eq flag 2) 'double)
+ ((eq flag 3) 'taarna)
+ ((eq flag '-) (setq c-box-default-style 'plain) 'plain)
+ ((eq flag -1) (setq c-box-default-style 'single) 'single)
+ ((eq flag -2) (setq c-box-default-style 'double) 'double)
+ ((eq flag -3) (setq c-box-default-style 'taarna) 'taarna)
+ (t c-box-default-style))))
;; - compute the left margin
@@ -283,10 +283,10 @@
(untabify (point-min) (point-max))
(if refill
- (let ((fill-prefix (make-string left-margin ? ))
- (fill-column (- fill-column
- (if (memq box-style '(single double)) 4 6))))
- (fill-region (point-min) (point-max))))
+ (let ((fill-prefix (make-string left-margin ? ))
+ (fill-column (- fill-column
+ (if (memq box-style '(single double)) 4 6))))
+ (fill-region (point-min) (point-max))))
;; - compute the right margin after refill
@@ -302,87 +302,87 @@
;; - move the right margin to account for left inserts
(setq right-margin (+ right-margin
- (if (memq box-style '(single double))
- 2
- 3)))
+ (if (memq box-style '(single double))
+ 2
+ 3)))
;; - construct the box comment, from top to bottom
(goto-char (point-min))
(cond ((eq box-style 'plain)
- ;; - construct a plain style comment
-
- (skip-chars-forward " " (+ (point) left-margin))
- (insert (make-string (- left-margin (current-column)) ? )
- "/* ")
- (end-of-line)
- (forward-char 1)
- (while (not (eobp))
- (skip-chars-forward " " (+ (point) left-margin))
- (insert (make-string (- left-margin (current-column)) ? )
- " ")
- (end-of-line)
- (forward-char 1))
- (backward-char 1)
- (insert " */"))
- ((eq box-style 'single)
-
- ;; - construct a single line style comment
-
- (indent-to left-margin)
- (insert "/*")
- (insert (make-string (- right-margin (current-column)) ?-)
- "-.\n")
- (while (not (eobp))
- (skip-chars-forward " " (+ (point) left-margin))
- (insert (make-string (- left-margin (current-column)) ? )
- "| ")
- (end-of-line)
- (indent-to right-margin)
- (insert " |")
- (forward-char 1))
- (indent-to left-margin)
- (insert "`")
- (insert (make-string (- right-margin (current-column)) ?-)
- "*/\n"))
- ((eq box-style 'double)
-
- ;; - construct a double line style comment
-
- (indent-to left-margin)
- (insert "/*")
- (insert (make-string (- right-margin (current-column)) ?=)
- "=\\\n")
- (while (not (eobp))
- (skip-chars-forward " " (+ (point) left-margin))
- (insert (make-string (- left-margin (current-column)) ? )
- "| ")
- (end-of-line)
- (indent-to right-margin)
- (insert " |")
- (forward-char 1))
- (indent-to left-margin)
- (insert "\\")
- (insert (make-string (- right-margin (current-column)) ?=)
- "*/\n"))
- ((eq box-style 'taarna)
-
- ;; - construct a Taarna style comment
-
- (while (not (eobp))
- (skip-chars-forward " " (+ (point) left-margin))
- (insert (make-string (- left-margin (current-column)) ? )
- "/* ")
- (end-of-line)
- (indent-to right-margin)
- (insert " */")
- (forward-char 1))
- (indent-to left-margin)
- (insert "/* ")
- (insert (make-string (- right-margin (current-column)) ?-)
- " */\n"))
- (t (error "unknown box style")))
+ ;; - construct a plain style comment
+
+ (skip-chars-forward " " (+ (point) left-margin))
+ (insert (make-string (- left-margin (current-column)) ? )
+ "/* ")
+ (end-of-line)
+ (forward-char 1)
+ (while (not (eobp))
+ (skip-chars-forward " " (+ (point) left-margin))
+ (insert (make-string (- left-margin (current-column)) ? )
+ " ")
+ (end-of-line)
+ (forward-char 1))
+ (backward-char 1)
+ (insert " */"))
+ ((eq box-style 'single)
+
+ ;; - construct a single line style comment
+
+ (indent-to left-margin)
+ (insert "/*")
+ (insert (make-string (- right-margin (current-column)) ?-)
+ "-.\n")
+ (while (not (eobp))
+ (skip-chars-forward " " (+ (point) left-margin))
+ (insert (make-string (- left-margin (current-column)) ? )
+ "| ")
+ (end-of-line)
+ (indent-to right-margin)
+ (insert " |")
+ (forward-char 1))
+ (indent-to left-margin)
+ (insert "`")
+ (insert (make-string (- right-margin (current-column)) ?-)
+ "*/\n"))
+ ((eq box-style 'double)
+
+ ;; - construct a double line style comment
+
+ (indent-to left-margin)
+ (insert "/*")
+ (insert (make-string (- right-margin (current-column)) ?=)
+ "=\\\n")
+ (while (not (eobp))
+ (skip-chars-forward " " (+ (point) left-margin))
+ (insert (make-string (- left-margin (current-column)) ? )
+ "| ")
+ (end-of-line)
+ (indent-to right-margin)
+ (insert " |")
+ (forward-char 1))
+ (indent-to left-margin)
+ (insert "\\")
+ (insert (make-string (- right-margin (current-column)) ?=)
+ "*/\n"))
+ ((eq box-style 'taarna)
+
+ ;; - construct a Taarna style comment
+
+ (while (not (eobp))
+ (skip-chars-forward " " (+ (point) left-margin))
+ (insert (make-string (- left-margin (current-column)) ? )
+ "/* ")
+ (end-of-line)
+ (indent-to right-margin)
+ (insert " */")
+ (forward-char 1))
+ (indent-to left-margin)
+ (insert "/* ")
+ (insert (make-string (- right-margin (current-column)) ?-)
+ " */\n"))
+ (t (error "unknown box style")))
;; Fifth, retabify, restore the point position, then cleanup the
;; undo list of any boundary since we started.
@@ -391,10 +391,10 @@
(goto-char (point-min))
(while (re-search-forward "^[ \t][ \t][ \t]*" nil t)
- (let ((column (current-column))
- (indent-tabs-mode t))
- (delete-region (match-beginning 0) (point))
- (indent-to column)))
+ (let ((column (current-column))
+ (indent-tabs-mode t))
+ (delete-region (match-beginning 0) (point))
+ (indent-to column)))
;; - restore the point position
@@ -403,11 +403,11 @@
;; - remove all intermediate boundaries from the undo list
(if (not (eq buffer-undo-list undo-list))
- (let ((cursor buffer-undo-list))
- (while (not (eq (cdr cursor) undo-list))
- (if (car (cdr cursor))
- (setq cursor (cdr cursor))
- (rplacd cursor (cdr (cdr cursor))))))))))
+ (let ((cursor buffer-undo-list))
+ (while (not (eq (cdr cursor) undo-list))
+ (if (car (cdr cursor))
+ (setq cursor (cdr cursor))
+ (rplacd cursor (cdr (cdr cursor))))))))))
;;; Rebox a C comment without refilling it.
diff --git a/cfg.mk b/cfg.mk
index 7bb60ce..24ebd87 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -42,3 +42,9 @@ old_NEWS_hash = 0330971054cd4fb4e94b85fe367980f2
# Always use longhand copyrights.
update-copyright-env = UPDATE_COPYRIGHT_USE_INTERVALS=0
+
+# Indent only with spaces.
+sc_prohibit_tab_based_indentation:
+ @re='^ * ' \
+ msg='TAB in indentation; use only spaces' \
+ $(_prohibit_regexp)
diff --git a/checks/check-them b/checks/check-them
index 997bb03..893548b 100755
--- a/checks/check-them
+++ b/checks/check-them
@@ -126,7 +126,7 @@ do
cp $err $xerr ;;
'')
${SED} '/^dnl @error{}/!d
- s///; '"s|^m4:|$m4name:|; s|examples/|$examples/|" \
+ s///; '"s|^m4:|$m4name:|; s|examples/|$examples/|" \
"$file" > $xerr ;;
*)
# This is a no-op for GNU sed, but is important for Solaris sed
diff --git a/checks/get-them b/checks/get-them
index 9310a9d..f2eba80 100755
--- a/checks/get-them
+++ b/checks/get-them
@@ -93,18 +93,18 @@ BEGIN {
count++;
file = sprintf("%03d.%s", count, node);
printf("dnl @ %s:%d: Origin of test\n"\
- "dnl @ expected status: %d\n"\
- "dnl @ extra options: %s\n"\
- "dnl @ Copyright (C) 2006, 2007, 2008, 2009 Free Software\n"\
- "dnl @ Foundation, Inc.\n"\
- "dnl @ This file is free software; the Free Software Foundation\n"\
- "dnl @ gives unlimited permission to copy and/or distribute it\n"\
- "dnl @ with or without modifications, as long as this notice\n"\
- "dnl @ is preserved.\n", FILENAME, NR, status, options) > file;
+ "dnl @ expected status: %d\n"\
+ "dnl @ extra options: %s\n"\
+ "dnl @ Copyright (C) 2006, 2007, 2008, 2009 Free Software\n"\
+ "dnl @ Foundation, Inc.\n"\
+ "dnl @ This file is free software; the Free Software Foundation\n"\
+ "dnl @ gives unlimited permission to copy and/or distribute it\n"\
+ "dnl @ with or without modifications, as long as this notice\n"\
+ "dnl @ is preserved.\n", FILENAME, NR, status, options) > file;
if (xout)
- printf("dnl @ expected output: %s\n", xout) > file;
+ printf("dnl @ expected output: %s\n", xout) > file;
if (xerr)
- printf("dnl @ expected error: %s\n", xerr) > file;
+ printf("dnl @ expected error: %s\n", xerr) > file;
status = 0;
options = "";
xout = "";
diff --git a/configure.ac b/configure.ac
index ea8d6ac..162a5e0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -205,15 +205,15 @@ dnl Give mingw a default that is more likely to be
available.
dnl Too bad _AS_PATH_WALK is not public.
M4_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for M4_dir in `if (command -p getconf PATH) 2>/dev/null ; then
- command -p getconf PATH
+ command -p getconf PATH
else
- echo "/bin$PATH_SEPARATOR$PATH"
+ echo "/bin$PATH_SEPARATOR$PATH"
fi`
do
IFS=$M4_save_IFS
test -z "$M4_dir" && continue
AS_EXECUTABLE_P(["$M4_dir/sh"]) \
- && { with_syscmd_shell=$M4_dir/sh; break; }
+ && { with_syscmd_shell=$M4_dir/sh; break; }
done
IFS=$M4_save_IFS
fi
@@ -227,12 +227,12 @@ M4_WITH_DMALLOC
AC_CONFIG_COMMANDS([stamp-h], [[test -z "$CONFIG_HEADERS" || date > stamp-h]])
AC_CONFIG_FILES([Makefile
- doc/Makefile
- lib/Makefile
- src/Makefile
- tests/Makefile
- checks/Makefile
- examples/Makefile
+ doc/Makefile
+ lib/Makefile
+ src/Makefile
+ tests/Makefile
+ checks/Makefile
+ examples/Makefile
])
AC_OUTPUT
diff --git a/examples/stackovf.sh b/examples/stackovf.sh
index 43fd68e..28dbaf1 100644
--- a/examples/stackovf.sh
+++ b/examples/stackovf.sh
@@ -7,13 +7,13 @@
# On some systems the ulimit command is available in ksh or bash but not sh
(exec 2>/dev/null; ulimit -HSs 300) || {
for altshell in bash bsh ksh ; do
- if (exec >/dev/null 2>&1; $altshell -c 'ulimit -HSs 300') &&
- test -z "$1"
- then
- echo "Using $altshell because it supports ulimit"
- exec $altshell $0 running-with-$altshell
- exit 9
- fi
+ if (exec >/dev/null 2>&1; $altshell -c 'ulimit -HSs 300') &&
+ test -z "$1"
+ then
+ echo "Using $altshell because it supports ulimit"
+ exec $altshell $0 running-with-$altshell
+ exit 9
+ fi
done
}
@@ -29,26 +29,26 @@ perl -e '
# Generate nested define sequence
$max=1000000;
for ($i=0; $i<$max; $i++) {
- print "define(X$i,\n";
+ print "define(X$i,\n";
}
for ($i=$max-1; $i>=0; $i--) {
- print "body with substance no. $i)dnl\n"
+ print "body with substance no. $i)dnl\n"
}
' | \
(
# Limit the stack size if the shell we are running permits it
if (exec 2>/dev/null; ulimit -HSs 50)
then
- (exec >/dev/null 2>&1; ulimit -v) && ulimitdashv=ok
- ulimit -HSs 50
- #ulimit -HSd 8000
- #test -n "$ulimitdashv" && ulimit -HSv 8000
- echo "Stack limit is `ulimit -s`K";
- echo "Heap limit is `ulimit -d`K";
- test -n "$ulimitdashv" &&
- echo "VMem limit is `ulimit -v`K";
+ (exec >/dev/null 2>&1; ulimit -v) && ulimitdashv=ok
+ ulimit -HSs 50
+ #ulimit -HSd 8000
+ #test -n "$ulimitdashv" && ulimit -HSv 8000
+ echo "Stack limit is `ulimit -s`K";
+ echo "Heap limit is `ulimit -d`K";
+ test -n "$ulimitdashv" &&
+ echo "VMem limit is `ulimit -v`K";
else
- echo "Can't reset stack limit - this may take a while..."
+ echo "Can't reset stack limit - this may take a while..."
fi
$M4 -L999999999 > $tmpfile 2>&1
)
@@ -61,14 +61,14 @@ else
# See if stack overflow was diagnosed
case "`cat $tmpfile`" in
*overflow*)
- echo "Test succeeded.";
- exitcode=0
- ;;
+ echo "Test succeeded.";
+ exitcode=0
+ ;;
*ut*of*emory*)
- echo "*** Test is INCONCLUSIVE (ran out of heap before stack overflow)";
- ;;
+ echo "*** Test is INCONCLUSIVE (ran out of heap before stack
overflow)";
+ ;;
*) echo "*** Test FAILED. $M4 aborted unexpectedly. Output:";
- ;;
+ ;;
esac
fi
diff --git a/gnulib b/gnulib
index c0c5acf..9c40f34 160000
--- a/gnulib
+++ b/gnulib
@@ -1 +1 @@
-Subproject commit c0c5acfbe255f5542bc1c81c7aec223d95e504a6
+Subproject commit 9c40f34443ba034ee7890ab10c369a903417765d
diff --git a/m4/gnulib-cache.m4 b/m4/gnulib-cache.m4
index d38c7ee..44d9255 100644
--- a/m4/gnulib-cache.m4
+++ b/m4/gnulib-cache.m4
@@ -15,7 +15,7 @@
# Specification in the form of a command-line invocation:
-# gnulib-tool --import --dir=. --local-dir=local --lib=libm4
--source-base=lib --m4-base=m4 --doc-base=doc --tests-base=tests
--aux-dir=build-aux --with-tests --makefile-name=gnulib.mk --no-libtool
--macro-prefix=M4 announce-gen assert autobuild avltree-oset binary-io
bitrotate clean-temp cloexec close-stream closein config-h dirname error
execute fdl-1.3 fflush filenamecat flexmember fopen fopen-safer freadptr
freadseek fseeko gendocs getopt-gnu git-version-gen gnu-web-doc-update
gnumakefile gnupload gpl-3.0 hash ignore-value intprops maintainer-makefile
manywarnings memchr2 memcmp2 memmem mkstemp obstack obstack-printf-posix pipe
progname quote regex rename snprintf-posix stdbool stdint stdlib-safer strtod
strtol unlocked-io update-copyright vasnprintf-posix verror version-etc
version-etc-fsf wait-process xalloc xmemdup0 xprintf xvasprintf-posix
+# gnulib-tool --import --dir=. --local-dir=local --lib=libm4
--source-base=lib --m4-base=m4 --doc-base=doc --tests-base=tests
--aux-dir=build-aux --with-tests --makefile-name=gnulib.mk --no-libtool
--macro-prefix=M4 announce-gen assert autobuild avltree-oset binary-io
bitrotate clean-temp cloexec close-stream closein config-h dirname error
execute fdl-1.3 fflush filenamecat flexmember fopen fopen-safer freadptr
freadseek fseeko gendocs getopt-gnu git-version-gen gnu-web-doc-update
gnumakefile gnupload gpl-3.0 hash ignore-value intprops maintainer-makefile
manywarnings memchr2 memcmp2 memmem mkstemp obstack obstack-printf-posix pipe
progname quote regex rename snprintf-posix stdbool stdint stdlib-safer strtod
strtol unlocked-io update-copyright vasnprintf-posix verror version-etc
version-etc-fsf wait-process xalloc xmemdup0 xoset xprintf xvasprintf-posix
# Specification in the form of a few gnulib-tool.m4 macro invocations:
gl_LOCAL_DIR([local])
@@ -81,6 +81,7 @@ gl_MODULES([
wait-process
xalloc
xmemdup0
+ xoset
xprintf
xvasprintf-posix
])
diff --git a/src/builtin.c b/src/builtin.c
index b04abc5..bf111fb 100644
--- a/src/builtin.c
+++ b/src/builtin.c
@@ -209,16 +209,16 @@ find_builtin_by_name (const char *name)
`------------------------------------------------------------------*/
void
func_print (struct obstack *obs, const builtin *func, bool flatten,
- token_chain **chain, const string_pair *quotes)
+ token_chain **chain, const string_pair *quotes)
{
assert (func);
if (flatten)
{
if (quotes)
- {
- obstack_grow (obs, quotes->str1, quotes->len1);
- obstack_grow (obs, quotes->str2, quotes->len2);
- }
+ {
+ obstack_grow (obs, quotes->str1, quotes->len1);
+ obstack_grow (obs, quotes->str2, quotes->len2);
+ }
}
else if (chain)
append_macro (obs, func->func, NULL, chain);
@@ -238,7 +238,7 @@ func_print (struct obstack *obs, const builtin *func, bool
flatten,
void
define_builtin (const char *name, size_t len, const builtin *bp,
- symbol_lookup mode)
+ symbol_lookup mode)
{
symbol *sym;
@@ -292,7 +292,7 @@ extern FILE *trace_file;
`------------------------------------------------------------------*/
static const char *
compile_pattern (const char *str, size_t len, struct re_pattern_buffer **buf,
- struct re_registers **regs)
+ struct re_registers **regs)
{
int i;
m4_regex *victim;
@@ -305,20 +305,20 @@ compile_pattern (const char *str, size_t len, struct
re_pattern_buffer **buf,
count and return it. */
for (i = 0; i < REGEX_CACHE_SIZE; i++)
if (len == regex_cache[i].len && regex_cache[i].str
- && memcmp (str, regex_cache[i].str, len) == 0)
+ && memcmp (str, regex_cache[i].str, len) == 0)
{
- *buf = regex_cache[i].buf;
- *regs = ®ex_cache[i].regs;
- regex_cache[i].count++;
+ *buf = regex_cache[i].buf;
+ *regs = ®ex_cache[i].regs;
+ regex_cache[i].count++;
#ifdef DEBUG_REGEX
- if (trace_file)
- {
- fputs ("cached:{", trace_file);
- xfwrite (str, 1, len, trace_file);
- fputs ("}\n", trace_file);
- }
+ if (trace_file)
+ {
+ fputs ("cached:{", trace_file);
+ xfwrite (str, 1, len, trace_file);
+ fputs ("}\n", trace_file);
+ }
#endif /* DEBUG_REGEX */
- return NULL;
+ return NULL;
}
/* Next, check if STR can be compiled. */
@@ -352,12 +352,12 @@ compile_pattern (const char *str, size_t len, struct
re_pattern_buffer **buf,
for (i = 1; i < REGEX_CACHE_SIZE; i++)
{
if (regex_cache[i].count < victim_count)
- {
- victim_count = regex_cache[i].count;
- victim = ®ex_cache[i];
- }
+ {
+ victim_count = regex_cache[i].count;
+ victim = ®ex_cache[i];
+ }
if (regex_cache[i].count)
- regex_cache[i].count--;
+ regex_cache[i].count--;
}
victim->count = REGEX_CACHE_SIZE;
victim->len = len;
@@ -365,11 +365,11 @@ compile_pattern (const char *str, size_t len, struct
re_pattern_buffer **buf,
{
#ifdef DEBUG_REGEX
if (trace_file)
- {
- fputs ("flush:{", trace_file);
- xfwrite (victim->str, 1, victim->len, trace_file);
- fputs ("}\n", trace_file);
- }
+ {
+ fputs ("flush:{", trace_file);
+ xfwrite (victim->str, 1, victim->len, trace_file);
+ fputs ("}\n", trace_file);
+ }
#endif /* DEBUG_REGEX */
free (victim->str);
regfree (victim->buf);
@@ -379,7 +379,7 @@ compile_pattern (const char *str, size_t len, struct
re_pattern_buffer **buf,
victim->buf = new_buf;
new_regs = &victim->regs;
re_set_registers (new_buf, new_regs, new_regs->num_regs,
- new_regs->start, new_regs->end);
+ new_regs->start, new_regs->end);
*buf = new_buf;
*regs = new_regs;
return NULL;
@@ -417,11 +417,11 @@ set_macro_sequence (const char *regexp)
msg = re_compile_pattern (regexp, strlen (regexp), ¯o_sequence_buf);
if (msg != NULL)
m4_error (EXIT_FAILURE, 0, NULL,
- _("--warn-macro-sequence: bad regular expression %s: %s"),
- quotearg_style (locale_quoting_style, regexp), msg);
+ _("--warn-macro-sequence: bad regular expression %s: %s"),
+ quotearg_style (locale_quoting_style, regexp), msg);
re_set_registers (¯o_sequence_buf, ¯o_sequence_regs,
- macro_sequence_regs.num_regs,
- macro_sequence_regs.start, macro_sequence_regs.end);
+ macro_sequence_regs.num_regs,
+ macro_sequence_regs.start, macro_sequence_regs.end);
macro_sequence_inuse = true;
}
@@ -436,9 +436,9 @@ free_regex (void)
for (i = 0; i < REGEX_CACHE_SIZE; i++)
if (regex_cache[i].str)
{
- free (regex_cache[i].str);
- free_pattern_buffer (regex_cache[i].buf, ®ex_cache[i].regs);
- free (regex_cache[i].buf);
+ free (regex_cache[i].str);
+ free_pattern_buffer (regex_cache[i].buf, ®ex_cache[i].regs);
+ free (regex_cache[i].buf);
}
}
@@ -452,7 +452,7 @@ free_regex (void)
void
define_user_macro (const char *name, size_t name_len, const char *text,
- size_t len, symbol_lookup mode)
+ size_t len, symbol_lookup mode)
{
symbol *s;
char *defn;
@@ -477,29 +477,29 @@ define_user_macro (const char *name, size_t name_len,
const char *text,
struct re_registers *regs = ¯o_sequence_regs;
while (offset < (regoff_t) len
- && (offset = re_search (¯o_sequence_buf, defn, len, offset,
- len - offset, regs)) >= 0)
- {
- /* Skip empty matches. */
- if (regs->start[0] == regs->end[0])
- offset++;
- else
- {
- offset = regs->end[0];
- /* Safe to use slot 1 since we don't pass a macro name
- to m4_warn. */
- m4_warn (0, NULL, _("definition of %s contains sequence %s"),
- quotearg_style_mem (locale_quoting_style, name,
- name_len),
- quotearg_n_style_mem (1, locale_quoting_style,
- defn + regs->start[0],
- regs->end[0] - regs->start[0]));
- }
- }
+ && (offset = re_search (¯o_sequence_buf, defn, len, offset,
+ len - offset, regs)) >= 0)
+ {
+ /* Skip empty matches. */
+ if (regs->start[0] == regs->end[0])
+ offset++;
+ else
+ {
+ offset = regs->end[0];
+ /* Safe to use slot 1 since we don't pass a macro name
+ to m4_warn. */
+ m4_warn (0, NULL, _("definition of %s contains sequence %s"),
+ quotearg_style_mem (locale_quoting_style, name,
+ name_len),
+ quotearg_n_style_mem (1, locale_quoting_style,
+ defn + regs->start[0],
+ regs->end[0] - regs->start[0]));
+ }
+ }
if (offset == -2)
- m4_warn (0, NULL,
- _("problem checking --warn-macro-sequence for macro %s"),
- quotearg_style_mem (locale_quoting_style, name, name_len));
+ m4_warn (0, NULL,
+ _("problem checking --warn-macro-sequence for macro %s"),
+ quotearg_style_mem (locale_quoting_style, name, name_len));
}
}
@@ -517,29 +517,29 @@ builtin_init (void)
for (bp = &builtin_tab[0]; bp->name != NULL; bp++)
if (!no_gnu_extensions || !bp->gnu_extension)
{
- size_t len = strlen (bp->name);
- if (prefix_all_builtins)
- {
- string = xasprintf ("m4_%s", bp->name);
- define_builtin (string, len + 3, bp, SYMBOL_INSERT);
- free (string);
- }
- else
- define_builtin (bp->name, len, bp, SYMBOL_INSERT);
+ size_t len = strlen (bp->name);
+ if (prefix_all_builtins)
+ {
+ string = xasprintf ("m4_%s", bp->name);
+ define_builtin (string, len + 3, bp, SYMBOL_INSERT);
+ free (string);
+ }
+ else
+ define_builtin (bp->name, len, bp, SYMBOL_INSERT);
}
for (pp = &predefined_tab[0]; pp->func != NULL; pp++)
if (no_gnu_extensions)
{
- if (pp->unix_name != NULL)
- define_user_macro (pp->unix_name, strlen (pp->unix_name),
- pp->func, SIZE_MAX, SYMBOL_INSERT);
+ if (pp->unix_name != NULL)
+ define_user_macro (pp->unix_name, strlen (pp->unix_name),
+ pp->func, SIZE_MAX, SYMBOL_INSERT);
}
else
{
- if (pp->gnu_name != NULL)
- define_user_macro (pp->gnu_name, strlen (pp->gnu_name),
- pp->func, SIZE_MAX, SYMBOL_INSERT);
+ if (pp->gnu_name != NULL)
+ define_user_macro (pp->gnu_name, strlen (pp->gnu_name),
+ pp->func, SIZE_MAX, SYMBOL_INSERT);
}
}
@@ -586,15 +586,15 @@ numeric_arg (const call_info *name, const char *arg,
size_t len, int *valuep)
errno = 0;
*valuep = strtol (arg, &endp, 10);
if (endp - arg - len)
- {
- m4_warn (0, name, _("non-numeric argument %s"),
- quotearg_style_mem (locale_quoting_style, arg, len));
- return false;
- }
+ {
+ m4_warn (0, name, _("non-numeric argument %s"),
+ quotearg_style_mem (locale_quoting_style, arg, len));
+ return false;
+ }
if (isspace (to_uchar (*arg)))
- m4_warn (0, name, _("leading whitespace ignored"));
+ m4_warn (0, name, _("leading whitespace ignored"));
else if (errno == ERANGE)
- m4_warn (0, name, _("numeric overflow detected"));
+ m4_warn (0, name, _("numeric overflow detected"));
}
return true;
}
@@ -705,15 +705,15 @@ define_macro (int argc, macro_arguments *argv,
symbol_lookup mode)
/* fallthru */
case TOKEN_TEXT:
define_user_macro (ARG (1), ARG_LEN (1), arg_text (argv, 2, true),
- arg_len (argv, 2, true), mode);
+ arg_len (argv, 2, true), mode);
break;
case TOKEN_FUNC:
bp = find_builtin_by_addr (arg_func (argv, 2));
if (bp == NULL)
- return;
+ return;
else
- define_builtin (ARG (1), ARG_LEN (1), bp, mode);
+ define_builtin (ARG (1), ARG_LEN (1), bp, mode);
break;
default:
@@ -730,7 +730,7 @@ m4_define (struct obstack *obs M4_GNUC_UNUSED, int argc,
macro_arguments *argv)
static void
m4_undefine (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
int i;
@@ -740,15 +740,15 @@ m4_undefine (struct obstack *obs M4_GNUC_UNUSED, int argc,
if (arg_type (argv, i) != TOKEN_TEXT)
m4_warn (0, me, _("invalid macro name ignored"));
else if (!lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_DELETE)
- && (debug_level & DEBUG_TRACE_DEREF))
+ && (debug_level & DEBUG_TRACE_DEREF))
m4_warn (0, me, _("undefined macro %s"),
- quotearg_style_mem (locale_quoting_style, ARG (i),
- ARG_LEN (i)));
+ quotearg_style_mem (locale_quoting_style, ARG (i),
+ ARG_LEN (i)));
}
static void
m4_pushdef (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
define_macro (argc, argv, SYMBOL_PUSHDEF);
}
@@ -764,10 +764,10 @@ m4_popdef (struct obstack *obs M4_GNUC_UNUSED, int argc,
macro_arguments *argv)
if (arg_type (argv, i) != TOKEN_TEXT)
m4_warn (0, me, _("invalid macro name ignored"));
else if (!lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_POPDEF)
- && (debug_level & DEBUG_TRACE_DEREF))
+ && (debug_level & DEBUG_TRACE_DEREF))
m4_warn (0, me, _("undefined macro %s"),
- quotearg_style_mem (locale_quoting_style, ARG (i),
- ARG_LEN (i)));
+ quotearg_style_mem (locale_quoting_style, ARG (i),
+ ARG_LEN (i)));
}
/*---------------------.
@@ -810,24 +810,24 @@ m4_ifelse (struct obstack *obs, int argc, macro_arguments
*argv)
while (true)
{
if (arg_equal (argv, i, i + 1))
- {
- push_arg (obs, argv, i + 2);
- return;
- }
+ {
+ push_arg (obs, argv, i + 2);
+ return;
+ }
switch (argc)
- {
- case 3:
- return;
+ {
+ case 3:
+ return;
- case 4:
- case 5:
- push_arg (obs, argv, i + 3);
- return;
+ case 4:
+ case 5:
+ push_arg (obs, argv, i + 3);
+ return;
- default:
- argc -= 3;
- i += 3;
- }
+ default:
+ argc -= 3;
+ i += 3;
+ }
}
}
@@ -902,20 +902,20 @@ m4_dumpdef (struct obstack *obs, int argc,
macro_arguments *argv)
else
{
for (i = 1; i < argc; i++)
- {
- if (arg_type (argv, i) != TOKEN_TEXT)
- {
- m4_warn (0, me, _("invalid macro name ignored"));
- continue;
- }
- s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
- if (s != NULL && SYMBOL_TYPE (s) != TOKEN_VOID)
- dump_symbol (s, &data);
- else if (debug_level & DEBUG_TRACE_DEREF)
- m4_warn (0, me, _("undefined macro %s"),
- quotearg_style_mem (locale_quoting_style, ARG (i),
- ARG_LEN (i)));
- }
+ {
+ if (arg_type (argv, i) != TOKEN_TEXT)
+ {
+ m4_warn (0, me, _("invalid macro name ignored"));
+ continue;
+ }
+ s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
+ if (s != NULL && SYMBOL_TYPE (s) != TOKEN_VOID)
+ dump_symbol (s, &data);
+ else if (debug_level & DEBUG_TRACE_DEREF)
+ m4_warn (0, me, _("undefined macro %s"),
+ quotearg_style_mem (locale_quoting_style, ARG (i),
+ ARG_LEN (i)));
+ }
}
/* Make table of symbols invisible to expand_macro (). */
@@ -926,36 +926,36 @@ m4_dumpdef (struct obstack *obs, int argc,
macro_arguments *argv)
{
/* TODO - add debugmode(b) option to control quoting style? */
xfwrite (SYMBOL_NAME (data.base[0]), 1, SYMBOL_NAME_LEN (data.base[0]),
- output);
+ output);
fputc (':', output);
fputc ('\t', output);
switch (SYMBOL_TYPE (data.base[0]))
- {
- case TOKEN_TEXT:
- if (debug_level & DEBUG_TRACE_QUOTE)
- xfwrite (curr_quote.str1, 1, curr_quote.len1, output);
- xfwrite (SYMBOL_TEXT (data.base[0]), 1,
- SYMBOL_TEXT_LEN (data.base[0]), output);
- if (debug_level & DEBUG_TRACE_QUOTE)
- xfwrite (curr_quote.str2, 1, curr_quote.len2, output);
- break;
-
- case TOKEN_FUNC:
- bp = find_builtin_by_addr (SYMBOL_FUNC (data.base[0]));
- if (bp == NULL)
- {
- assert (!"m4_dumpdef");
- abort ();
- }
- xfprintf (output, "<%s>", bp->name);
- break;
-
- default:
- assert (!"m4_dumpdef");
- abort ();
- break;
- }
+ {
+ case TOKEN_TEXT:
+ if (debug_level & DEBUG_TRACE_QUOTE)
+ xfwrite (curr_quote.str1, 1, curr_quote.len1, output);
+ xfwrite (SYMBOL_TEXT (data.base[0]), 1,
+ SYMBOL_TEXT_LEN (data.base[0]), output);
+ if (debug_level & DEBUG_TRACE_QUOTE)
+ xfwrite (curr_quote.str2, 1, curr_quote.len2, output);
+ break;
+
+ case TOKEN_FUNC:
+ bp = find_builtin_by_addr (SYMBOL_FUNC (data.base[0]));
+ if (bp == NULL)
+ {
+ assert (!"m4_dumpdef");
+ abort ();
+ }
+ xfprintf (output, "<%s>", bp->name);
+ break;
+
+ default:
+ assert (!"m4_dumpdef");
+ abort ();
+ break;
+ }
fputc ('\n', output);
}
}
@@ -987,13 +987,13 @@ m4_builtin (struct obstack *obs, int argc,
macro_arguments *argv)
if (bp->func == m4_placeholder)
{
if (debug_level & DEBUG_TRACE_DEREF)
- m4_warn (0, me, _("undefined builtin %s"),
- quotearg_style_mem (locale_quoting_style, name, ARG_LEN (1)));
+ m4_warn (0, me, _("undefined builtin %s"),
+ quotearg_style_mem (locale_quoting_style, name, ARG_LEN (1)));
}
else
{
macro_arguments *new_argv = make_argv_ref (argv, name, ARG_LEN (1),
- !bp->groks_macro_args, false);
+ !bp->groks_macro_args, false);
bp->func (obs, argc - 1, new_argv);
}
}
@@ -1027,14 +1027,14 @@ m4_indir (struct obstack *obs, int argc,
macro_arguments *argv)
if (s == NULL || SYMBOL_TYPE (s) == TOKEN_VOID)
{
if (debug_level & DEBUG_TRACE_DEREF)
- m4_warn (0, me, _("undefined macro %s"),
- quotearg_style_mem (locale_quoting_style, name, len));
+ m4_warn (0, me, _("undefined macro %s"),
+ quotearg_style_mem (locale_quoting_style, name, len));
}
else
{
macro_arguments *new_argv = make_argv_ref (argv, name, len,
- !SYMBOL_MACRO_ARGS (s),
- SYMBOL_TRACED (s));
+ !SYMBOL_MACRO_ARGS (s),
+ SYMBOL_TRACED (s));
trace_prepre (arg_info (new_argv));
call_macro (s, new_argv, obs);
}
@@ -1060,43 +1060,43 @@ m4_defn (struct obstack *obs, int argc, macro_arguments
*argv)
for (i = 1; i < argc; i++)
{
if (arg_type (argv, i) != TOKEN_TEXT)
- {
- m4_warn (0, me, _("invalid macro name ignored"));
- continue;
- }
+ {
+ m4_warn (0, me, _("invalid macro name ignored"));
+ continue;
+ }
s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
if (s == NULL || SYMBOL_TYPE (s) == TOKEN_VOID)
- {
- if (debug_level & DEBUG_TRACE_DEREF)
- m4_warn (0, me, _("undefined macro %s"),
- quotearg_style_mem (locale_quoting_style, ARG (i),
- ARG_LEN (i)));
- continue;
- }
+ {
+ if (debug_level & DEBUG_TRACE_DEREF)
+ m4_warn (0, me, _("undefined macro %s"),
+ quotearg_style_mem (locale_quoting_style, ARG (i),
+ ARG_LEN (i)));
+ continue;
+ }
switch (SYMBOL_TYPE (s))
- {
- case TOKEN_TEXT:
- obstack_grow (obs, curr_quote.str1, curr_quote.len1);
- obstack_grow (obs, SYMBOL_TEXT (s), SYMBOL_TEXT_LEN (s));
- obstack_grow (obs, curr_quote.str2, curr_quote.len2);
- break;
-
- case TOKEN_FUNC:
- b = SYMBOL_FUNC (s);
- if (b == m4_placeholder)
- m4_warn (0, me,
- _("builtin %s requested by frozen file not found"),
- quotearg_style_mem (locale_quoting_style, ARG (i),
- ARG_LEN (i)));
- else
- push_macro (obs, b);
- break;
-
- default:
- assert (!"m4_defn");
- abort ();
- }
+ {
+ case TOKEN_TEXT:
+ obstack_grow (obs, curr_quote.str1, curr_quote.len1);
+ obstack_grow (obs, SYMBOL_TEXT (s), SYMBOL_TEXT_LEN (s));
+ obstack_grow (obs, curr_quote.str2, curr_quote.len2);
+ break;
+
+ case TOKEN_FUNC:
+ b = SYMBOL_FUNC (s);
+ if (b == m4_placeholder)
+ m4_warn (0, me,
+ _("builtin %s requested by frozen file not found"),
+ quotearg_style_mem (locale_quoting_style, ARG (i),
+ ARG_LEN (i)));
+ else
+ push_macro (obs, b);
+ break;
+
+ default:
+ assert (!"m4_defn");
+ abort ();
+ }
}
}
@@ -1121,7 +1121,7 @@ m4_syscmd (struct obstack *obs M4_GNUC_UNUSED, int argc,
macro_arguments *argv)
if (strlen (cmd) != len)
m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, cmd, len));
+ quotearg_style_mem (locale_quoting_style, cmd, len));
if (bad_argc (me, argc, 1, 1) || !*cmd)
{
/* The empty command is successful. */
@@ -1141,7 +1141,7 @@ m4_syscmd (struct obstack *obs M4_GNUC_UNUSED, int argc,
macro_arguments *argv)
caller = quotearg_style_mem (locale_quoting_style, me->name, me->name_len);
errno = 0;
status = execute (caller, SYSCMD_SHELL, (char **) prog_args, false,
- false, false, false, true, false, &sig_status);
+ false, false, false, true, false, &sig_status);
if (sig_status)
{
assert (status == 127);
@@ -1150,8 +1150,8 @@ m4_syscmd (struct obstack *obs M4_GNUC_UNUSED, int argc,
macro_arguments *argv)
else
{
if (status == 127 && errno)
- m4_warn (errno, me, _("cannot run command %s"),
- quotearg_style (locale_quoting_style, cmd));
+ m4_warn (errno, me, _("cannot run command %s"),
+ quotearg_style (locale_quoting_style, cmd));
sysval = status;
}
}
@@ -1172,7 +1172,7 @@ m4_esyscmd (struct obstack *obs, int argc,
macro_arguments *argv)
if (strlen (cmd) != len)
m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, cmd, len));
+ quotearg_style_mem (locale_quoting_style, cmd, len));
if (bad_argc (me, argc, 1, 1) || !*cmd)
{
/* The empty command is successful. */
@@ -1192,11 +1192,11 @@ m4_esyscmd (struct obstack *obs, int argc,
macro_arguments *argv)
caller = quotearg_style_mem (locale_quoting_style, me->name, me->name_len);
errno = 0;
child = create_pipe_in (caller, SYSCMD_SHELL, (char **) prog_args,
- NULL, false, true, false, &fd);
+ NULL, false, true, false, &fd);
if (child == -1)
{
m4_warn (errno, me, _("cannot run command %s"),
- quotearg_style (locale_quoting_style, cmd));
+ quotearg_style (locale_quoting_style, cmd));
sysval = 127;
return;
}
@@ -1204,7 +1204,7 @@ m4_esyscmd (struct obstack *obs, int argc,
macro_arguments *argv)
if (!pin)
{
m4_warn (errno, me, _("cannot run command %s"),
- quotearg_style (locale_quoting_style, cmd));
+ quotearg_style (locale_quoting_style, cmd));
sysval = 127;
close (fd);
return;
@@ -1213,26 +1213,26 @@ m4_esyscmd (struct obstack *obs, int argc,
macro_arguments *argv)
{
size_t avail = obstack_room (obs);
if (!avail)
- {
- int ch = getc (pin);
- if (ch == EOF)
- break;
- obstack_1grow (obs, ch);
- }
+ {
+ int ch = getc (pin);
+ if (ch == EOF)
+ break;
+ obstack_1grow (obs, ch);
+ }
else
- {
- len = fread (obstack_next_free (obs), 1, avail, pin);
- if (len <= 0)
- break;
- obstack_blank_fast (obs, len);
- }
+ {
+ len = fread (obstack_next_free (obs), 1, avail, pin);
+ if (len <= 0)
+ break;
+ obstack_blank_fast (obs, len);
+ }
}
if (ferror (pin) || fclose (pin))
m4_error (EXIT_FAILURE, errno, me, _("cannot read pipe to command %s"),
- quotearg_style (locale_quoting_style, cmd));
+ quotearg_style (locale_quoting_style, cmd));
errno = 0;
status = wait_subprocess (child, caller, false, true, true, false,
- &sig_status);
+ &sig_status);
if (sig_status)
{
assert (status == 127);
@@ -1241,15 +1241,15 @@ m4_esyscmd (struct obstack *obs, int argc,
macro_arguments *argv)
else
{
if (status == 127 && errno)
- m4_warn (errno, me, _("cannot run command %s"),
- quotearg_style (locale_quoting_style, cmd));
+ m4_warn (errno, me, _("cannot run command %s"),
+ quotearg_style (locale_quoting_style, cmd));
sysval = status;
}
}
static void
m4_sysval (struct obstack *obs, int argc M4_GNUC_UNUSED,
- macro_arguments *argv M4_GNUC_UNUSED)
+ macro_arguments *argv M4_GNUC_UNUSED)
{
shipout_int (obs, sysval);
}
@@ -1295,16 +1295,16 @@ m4_eval (struct obstack *obs, int argc, macro_arguments
*argv)
if (radix == 1)
{
if (value < 0)
- {
- obstack_1grow (obs, '-');
- value = -value;
- }
+ {
+ obstack_1grow (obs, '-');
+ value = -value;
+ }
if (value + 0U < min + 0U)
- {
- obstack_blank (obs, min - value);
- memset ((char *) obstack_next_free (obs) - (min - value), '0',
- min - value);
- }
+ {
+ obstack_blank (obs, min - value);
+ memset ((char *) obstack_next_free (obs) - (min - value), '0',
+ min - value);
+ }
obstack_blank (obs, value);
memset ((char *) obstack_next_free (obs) - value, '1', value);
return;
@@ -1399,7 +1399,7 @@ m4_divnum (struct obstack *obs, int argc, macro_arguments
*argv)
static void
m4_undivert (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
int i;
@@ -1412,31 +1412,31 @@ m4_undivert (struct obstack *obs M4_GNUC_UNUSED, int
argc,
else
for (i = 1; i < argc; i++)
{
- const char *str = ARG (i);
- size_t len = ARG_LEN (i);
- file = strtol (str, &endp, 10);
- if (endp - str + 0UL == len && !isspace (to_uchar (*str)))
- insert_diversion (file);
- else if (no_gnu_extensions)
- m4_warn (0, me, _("non-numeric argument %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
- else if (strlen (str) != len)
- m4_warn (0, me, _("invalid file name %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
- else
- {
- fp = m4_path_search (str, NULL);
- if (fp != NULL)
- {
- insert_file (fp);
- if (fclose (fp) == EOF)
- m4_warn (errno, me, _("error undiverting %s"),
- quotearg_style (locale_quoting_style, str));
- }
- else
- m4_warn (errno, me, _("cannot undivert %s"),
- quotearg_style (locale_quoting_style, str));
- }
+ const char *str = ARG (i);
+ size_t len = ARG_LEN (i);
+ file = strtol (str, &endp, 10);
+ if (endp - str + 0UL == len && !isspace (to_uchar (*str)))
+ insert_diversion (file);
+ else if (no_gnu_extensions)
+ m4_warn (0, me, _("non-numeric argument %s"),
+ quotearg_style_mem (locale_quoting_style, str, len));
+ else if (strlen (str) != len)
+ m4_warn (0, me, _("invalid file name %s"),
+ quotearg_style_mem (locale_quoting_style, str, len));
+ else
+ {
+ fp = m4_path_search (str, NULL);
+ if (fp != NULL)
+ {
+ insert_file (fp);
+ if (fclose (fp) == EOF)
+ m4_warn (errno, me, _("error undiverting %s"),
+ quotearg_style (locale_quoting_style, str));
+ }
+ else
+ m4_warn (errno, me, _("cannot undivert %s"),
+ quotearg_style (locale_quoting_style, str));
+ }
}
}
@@ -1477,13 +1477,13 @@ m4_shift (struct obstack *obs, int argc,
macro_arguments *argv)
static void
m4_changequote (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
bad_argc (arg_info (argv), argc, 0, 2);
/* Explicit NULL distinguishes between empty and missing argument. */
set_quotes ((argc >= 2) ? ARG (1) : NULL, ARG_LEN (1),
- (argc >= 3) ? ARG (2) : NULL, ARG_LEN (2));
+ (argc >= 3) ? ARG (2) : NULL, ARG_LEN (2));
}
/*--------------------------------------------------------------------.
@@ -1493,13 +1493,13 @@ m4_changequote (struct obstack *obs M4_GNUC_UNUSED, int
argc,
static void
m4_changecom (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
bad_argc (arg_info (argv), argc, 0, 2);
/* Explicit NULL distinguishes between empty and missing argument. */
set_comment ((argc >= 2) ? ARG (1) : NULL, ARG_LEN (1),
- (argc >= 3) ? ARG (2) : NULL, ARG_LEN (2));
+ (argc >= 3) ? ARG (2) : NULL, ARG_LEN (2));
}
#ifdef ENABLE_CHANGEWORD
@@ -1511,7 +1511,7 @@ m4_changecom (struct obstack *obs M4_GNUC_UNUSED, int
argc,
static void
m4_changeword (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
@@ -1547,13 +1547,13 @@ include (int argc, macro_arguments *argv, bool silent)
len = ARG_LEN (1);
if (strlen (arg) != len)
m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, arg, len));
+ quotearg_style_mem (locale_quoting_style, arg, len));
fp = m4_path_search (arg, &name);
if (fp == NULL)
{
if (!silent)
- m4_error (0, errno, me, _("cannot open %s"),
- quotearg_style (locale_quoting_style, arg));
+ m4_error (0, errno, me, _("cannot open %s"),
+ quotearg_style (locale_quoting_style, arg));
return;
}
@@ -1567,7 +1567,7 @@ include (int argc, macro_arguments *argv, bool silent)
static void
m4_include (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
include (argc, argv, false);
}
@@ -1578,7 +1578,7 @@ m4_include (struct obstack *obs M4_GNUC_UNUSED, int argc,
static void
m4_sinclude (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
include (argc, argv, true);
}
@@ -1595,7 +1595,7 @@ m4_sinclude (struct obstack *obs M4_GNUC_UNUSED, int argc,
OBS. Report errors on behalf of ME. */
static void
mkstemp_helper (struct obstack *obs, const call_info *me, const char *pattern,
- size_t len)
+ size_t len)
{
int fd;
int i;
@@ -1608,7 +1608,7 @@ mkstemp_helper (struct obstack *obs, const call_info *me,
const char *pattern,
if (strlen (pattern) < len)
{
m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, pattern, len));
+ quotearg_style_mem (locale_quoting_style, pattern, len));
len = strlen (pattern);
}
obstack_grow (obs, pattern, len);
@@ -1623,7 +1623,7 @@ mkstemp_helper (struct obstack *obs, const call_info *me,
const char *pattern,
if (fd < 0)
{
m4_warn (errno, me, _("cannot create file from template %s"),
- quotearg_style (locale_quoting_style, pattern));
+ quotearg_style (locale_quoting_style, pattern));
obstack_free (obs, obstack_finish (obs));
}
else
@@ -1646,32 +1646,32 @@ m4_maketemp (struct obstack *obs, int argc,
macro_arguments *argv)
if (no_gnu_extensions)
{
/* POSIX states "any trailing 'X' characters [are] replaced with
- the current process ID as a string", without referencing the
- file system. Horribly insecure, but we have to do it when we
- are in traditional mode.
-
- For reference, Solaris m4 does:
- maketemp() -> `'
- maketemp(X) -> `X'
- maketemp(XX) -> `Xn', where n is last digit of pid
- maketemp(XXXXXXXX) -> `X00nnnnn', where nnnnn is 16-bit pid
+ the current process ID as a string", without referencing the
+ file system. Horribly insecure, but we have to do it when we
+ are in traditional mode.
+
+ For reference, Solaris m4 does:
+ maketemp() -> `'
+ maketemp(X) -> `X'
+ maketemp(XX) -> `Xn', where n is last digit of pid
+ maketemp(XXXXXXXX) -> `X00nnnnn', where nnnnn is 16-bit pid
*/
const char *str = ARG (1);
size_t len = ARG_LEN (1);
size_t i;
struct obstack *scratch = arg_scratch ();
size_t pid_len = obstack_printf (scratch, "%lu",
- (unsigned long) getpid ());
+ (unsigned long) getpid ());
char *pid = (char *) obstack_copy0 (scratch, "", 0);
for (i = len; i > 1; i--)
- if (str[i - 1] != 'X')
- break;
+ if (str[i - 1] != 'X')
+ break;
obstack_grow (obs, str, i);
if (len - i < pid_len)
- obstack_grow (obs, pid + pid_len - (len - i), len - i);
+ obstack_grow (obs, pid + pid_len - (len - i), len - i);
else
- obstack_printf (obs, "%.*d%s", (int) (len - i - pid_len), 0, pid);
+ obstack_printf (obs, "%.*d%s", (int) (len - i - pid_len), 0, pid);
}
else
mkstemp_helper (obs, me, ARG (1), ARG_LEN (1));
@@ -1814,15 +1814,15 @@ m4_traceon (struct obstack *obs, int argc,
macro_arguments *argv)
else
for (i = 1; i < argc; i++)
{
- if (arg_type (argv, i) != TOKEN_TEXT)
- {
- m4_warn (0, me, _("invalid macro name ignored"));
- continue;
- }
- s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
- if (!s)
- s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_INSERT);
- set_trace (s, obs);
+ if (arg_type (argv, i) != TOKEN_TEXT)
+ {
+ m4_warn (0, me, _("invalid macro name ignored"));
+ continue;
+ }
+ s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
+ if (!s)
+ s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_INSERT);
+ set_trace (s, obs);
}
}
@@ -1832,7 +1832,7 @@ m4_traceon (struct obstack *obs, int argc,
macro_arguments *argv)
static void
m4_traceoff (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
symbol *s;
@@ -1843,14 +1843,14 @@ m4_traceoff (struct obstack *obs M4_GNUC_UNUSED, int
argc,
else
for (i = 1; i < argc; i++)
{
- if (arg_type (argv, i) != TOKEN_TEXT)
- {
- m4_warn (0, me, _("invalid macro name ignored"));
- continue;
- }
- s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
- if (s != NULL)
- set_trace (s, NULL);
+ if (arg_type (argv, i) != TOKEN_TEXT)
+ {
+ m4_warn (0, me, _("invalid macro name ignored"));
+ continue;
+ }
+ s = lookup_symbol (ARG (i), ARG_LEN (i), SYMBOL_LOOKUP);
+ if (s != NULL)
+ set_trace (s, NULL);
}
}
@@ -1862,7 +1862,7 @@ m4_traceoff (struct obstack *obs M4_GNUC_UNUSED, int argc,
static void
m4_debugmode (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
const char *str = ARG (1);
@@ -1874,7 +1874,7 @@ m4_debugmode (struct obstack *obs M4_GNUC_UNUSED, int
argc,
debug_level = 0;
else if (debug_decode (str, len) < 0)
m4_warn (0, me, _("bad debug flags: %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ quotearg_style_mem (locale_quoting_style, str, len));
}
/*-------------------------------------------------------------------------.
@@ -1884,7 +1884,7 @@ m4_debugmode (struct obstack *obs M4_GNUC_UNUSED, int
argc,
static void
m4_debugfile (struct obstack *obs M4_GNUC_UNUSED, int argc,
- macro_arguments *argv)
+ macro_arguments *argv)
{
const call_info *me = arg_info (argv);
@@ -1897,11 +1897,11 @@ m4_debugfile (struct obstack *obs M4_GNUC_UNUSED, int
argc,
const char *str = ARG (1);
size_t len = ARG_LEN (1);
if (strlen (str) < len)
- m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ m4_warn (0, me, _("argument %s truncated"),
+ quotearg_style_mem (locale_quoting_style, str, len));
if (!debug_set_output (me, str))
- m4_warn (errno, me, _("cannot set debug file %s"),
- quotearg_style (locale_quoting_style, str));
+ m4_warn (errno, me, _("cannot set debug file %s"),
+ quotearg_style (locale_quoting_style, str));
}
}
@@ -1941,7 +1941,7 @@ m4_index (struct obstack *obs, int argc, macro_arguments
*argv)
{
/* builtin(`index') is blank, but index(`abc') is 0. */
if (argc == 2)
- shipout_int (obs, 0);
+ shipout_int (obs, 0);
return;
}
@@ -1955,7 +1955,7 @@ m4_index (struct obstack *obs, int argc, macro_arguments
*argv)
{
offset += haystack_len;
if (offset < 0)
- offset = 0;
+ offset = 0;
}
else if (haystack_len < offset + 0UL)
{
@@ -1966,7 +1966,7 @@ m4_index (struct obstack *obs, int argc, macro_arguments
*argv)
/* Rely on the optimizations guaranteed by gnulib's memmem
module. */
result = (char *) memmem (haystack + offset, haystack_len - offset, needle,
- ARG_LEN (2));
+ ARG_LEN (2));
if (result)
retval = result - haystack;
@@ -1996,7 +1996,7 @@ m4_substr (struct obstack *obs, int argc, macro_arguments
*argv)
{
/* builtin(`substr') is blank, but substr(`abc') is abc. */
if (argc == 2)
- push_arg (obs, argv, 1);
+ push_arg (obs, argv, 1);
return;
}
@@ -2011,27 +2011,27 @@ m4_substr (struct obstack *obs, int argc,
macro_arguments *argv)
else
{
if (!numeric_arg (me, ARG (3), ARG_LEN (3), &end))
- return;
+ return;
if (end < 0)
- end += length;
+ end += length;
else
- end += start;
+ end += start;
}
if (argc >= 5)
{
/* Replacement text provided. */
if (end < start)
- end = start;
+ end = start;
if (end < 0 || length < start)
- {
- m4_warn (0, me, _("substring out of range"));
- return;
- }
+ {
+ m4_warn (0, me, _("substring out of range"));
+ return;
+ }
if (start < 0)
- start = 0;
+ start = 0;
if (length < end)
- end = length;
+ end = length;
obstack_grow (obs, ARG (1), start);
push_arg (obs, argv, 4);
obstack_grow (obs, ARG (1) + end, length - end);
@@ -2075,27 +2075,27 @@ expand_ranges (const char *s, size_t *len, struct
obstack *obs)
for ( ; s != end; from = *s++)
{
if (*s == '-')
- {
- if (++s == end)
- {
- /* trailing dash */
- obstack_1grow (obs, '-');
- break;
- }
- to = *s;
- if (from <= to)
- {
- while (from++ < to)
- obstack_1grow (obs, from);
- }
- else
- {
- while (--from >= to)
- obstack_1grow (obs, from);
- }
- }
+ {
+ if (++s == end)
+ {
+ /* trailing dash */
+ obstack_1grow (obs, '-');
+ break;
+ }
+ to = *s;
+ if (from <= to)
+ {
+ while (from++ < to)
+ obstack_1grow (obs, from);
+ }
+ else
+ {
+ while (--from >= to)
+ obstack_1grow (obs, from);
+ }
+ }
else
- obstack_1grow (obs, *s);
+ obstack_1grow (obs, *s);
}
*len = obstack_object_size (obs);
return (char *) obstack_finish (obs);
@@ -2128,7 +2128,7 @@ m4_translit (struct obstack *obs, int argc,
macro_arguments *argv)
{
/* builtin(`translit') is blank, but translit(`abc') is abc. */
if (argc >= 2)
- push_arg (obs, argv, 1);
+ push_arg (obs, argv, 1);
return;
}
@@ -2150,15 +2150,15 @@ m4_translit (struct obstack *obs, int argc,
macro_arguments *argv)
int second = from[from_len / 2];
data = ARG (1);
while ((p = (char *) memchr2 (data, from[0], second, len)))
- {
- obstack_grow (obs, data, p - data);
- len -= p - data + 1;
- data = p + 1;
- if (*p == from[0] && to_len)
- obstack_1grow (obs, to[0]);
- else if (*p == second && 1 < to_len)
- obstack_1grow (obs, to[1]);
- }
+ {
+ obstack_grow (obs, data, p - data);
+ len -= p - data + 1;
+ data = p + 1;
+ if (*p == from[0] && to_len)
+ obstack_1grow (obs, to[0]);
+ else if (*p == second && 1 < to_len)
+ obstack_1grow (obs, to[1]);
+ }
obstack_grow (obs, data, len);
return;
}
@@ -2178,20 +2178,20 @@ m4_translit (struct obstack *obs, int argc,
macro_arguments *argv)
{
ch = *from++;
if (found[ch] == ASIS)
- {
- if (to_len)
- {
- found[ch] = REPLACE;
- map[ch] = *to;
- }
- else
- found[ch] = DELETE;
- }
+ {
+ if (to_len)
+ {
+ found[ch] = REPLACE;
+ map[ch] = *to;
+ }
+ else
+ found[ch] = DELETE;
+ }
if (to_len)
- {
- to++;
- to_len--;
- }
+ {
+ to++;
+ to_len--;
+ }
}
data = ARG (1);
@@ -2200,19 +2200,19 @@ m4_translit (struct obstack *obs, int argc,
macro_arguments *argv)
{
ch = *data++;
switch (found[ch])
- {
- case ASIS:
- obstack_1grow (obs, ch);
- break;
- case REPLACE:
- obstack_1grow (obs, map[ch]);
- break;
- case DELETE:
- break;
- default:
- assert (!"m4_translit");
- abort ();
- }
+ {
+ case ASIS:
+ obstack_1grow (obs, ch);
+ break;
+ case REPLACE:
+ obstack_1grow (obs, map[ch]);
+ break;
+ case DELETE:
+ break;
+ default:
+ assert (!"m4_translit");
+ abort ();
+ }
}
}
@@ -2242,7 +2242,7 @@ static int substitute_warned = 0;
static void
substitute (struct obstack *obs, const call_info *me, const char *victim,
- const char *repl, size_t repl_len, struct re_registers *regs)
+ const char *repl, size_t repl_len, struct re_registers *regs)
{
int ch;
__re_size_t ind;
@@ -2250,51 +2250,51 @@ substitute (struct obstack *obs, const call_info *me,
const char *victim,
{
const char *backslash = (char *) memchr (repl, '\\', repl_len);
if (!backslash)
- {
- obstack_grow (obs, repl, repl_len);
- return;
- }
+ {
+ obstack_grow (obs, repl, repl_len);
+ return;
+ }
obstack_grow (obs, repl, backslash - repl);
repl_len -= backslash - repl + 1;
if (!repl_len)
- {
- m4_warn (0, me, _("trailing \\ ignored in replacement"));
- return;
- }
+ {
+ m4_warn (0, me, _("trailing \\ ignored in replacement"));
+ return;
+ }
repl = backslash + 1;
repl_len--;
ch = *repl++;
switch (ch)
- {
- case '0':
- if (!substitute_warned)
- {
- m4_warn (0, me, _("\
+ {
+ case '0':
+ if (!substitute_warned)
+ {
+ m4_warn (0, me, _("\
\\0 will disappear, use \\& instead in replacements"));
- substitute_warned = 1;
- }
- /* Fall through. */
+ substitute_warned = 1;
+ }
+ /* Fall through. */
- case '&':
- if (regs)
- obstack_grow (obs, victim + regs->start[0],
- regs->end[0] - regs->start[0]);
- break;
+ case '&':
+ if (regs)
+ obstack_grow (obs, victim + regs->start[0],
+ regs->end[0] - regs->start[0]);
+ break;
- case '1': case '2': case '3': case '4': case '5': case '6':
- case '7': case '8': case '9':
- ind = ch -= '0';
- if (!regs || regs->num_regs - 1 <= ind)
- m4_warn (0, me, _("sub-expression %d not present"), ch);
- else if (regs->end[ch] > 0)
- obstack_grow (obs, victim + regs->start[ch],
- regs->end[ch] - regs->start[ch]);
- break;
+ case '1': case '2': case '3': case '4': case '5': case '6':
+ case '7': case '8': case '9':
+ ind = ch -= '0';
+ if (!regs || regs->num_regs - 1 <= ind)
+ m4_warn (0, me, _("sub-expression %d not present"), ch);
+ else if (regs->end[ch] > 0)
+ obstack_grow (obs, victim + regs->start[ch],
+ regs->end[ch] - regs->start[ch]);
+ break;
- default:
- obstack_1grow (obs, ch);
- break;
- }
+ default:
+ obstack_1grow (obs, ch);
+ break;
+ }
}
}
@@ -2341,7 +2341,7 @@ m4_regexp (struct obstack *obs, int argc, macro_arguments
*argv)
{
/* builtin(`regexp') is blank, but regexp(`abc') is 0. */
if (argc == 2)
- shipout_int (obs, 0);
+ shipout_int (obs, 0);
return;
}
@@ -2353,9 +2353,9 @@ m4_regexp (struct obstack *obs, int argc, macro_arguments
*argv)
{
/* The empty regex matches everything! */
if (argc == 3)
- shipout_int (obs, 0);
+ shipout_int (obs, 0);
else
- substitute (obs, me, victim, repl, ARG_LEN (3), NULL);
+ substitute (obs, me, victim, repl, ARG_LEN (3), NULL);
return;
}
@@ -2365,10 +2365,10 @@ m4_regexp (struct obstack *obs, int argc,
macro_arguments *argv)
fputs ("r:{", trace_file);
xfwrite (regexp, 1, ARG_LEN (2), trace_file);
if (argc > 3)
- {
- fputs ("}:{", trace_file);
- xfwrite (repl, 1, ARG_LEN (3), trace_file);
- }
+ {
+ fputs ("}:{", trace_file);
+ xfwrite (repl, 1, ARG_LEN (3), trace_file);
+ }
fputs ("}\n", trace_file);
}
#endif /* DEBUG_REGEX */
@@ -2377,19 +2377,19 @@ m4_regexp (struct obstack *obs, int argc,
macro_arguments *argv)
if (msg != NULL)
{
m4_warn (0, me, _("bad regular expression %s: %s"),
- quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)),
- msg);
+ quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)),
+ msg);
return;
}
length = ARG_LEN (1);
/* Avoid overhead of allocating regs if we won't use it. */
startpos = re_search (buf, victim, length, 0, length,
- argc == 3 ? NULL : regs);
+ argc == 3 ? NULL : regs);
if (startpos == -2)
m4_warn (0, me, _("problem matching regular expression %s"),
- quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)));
+ quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)));
else if (argc == 3)
shipout_int (obs, startpos);
else if (startpos >= 0)
@@ -2424,7 +2424,7 @@ m4_patsubst (struct obstack *obs, int argc,
macro_arguments *argv)
{
/* builtin(`patsubst') is blank, but patsubst(`abc') is abc. */
if (argc == 2)
- push_arg (obs, argv, 1);
+ push_arg (obs, argv, 1);
return;
}
@@ -2456,8 +2456,8 @@ m4_patsubst (struct obstack *obs, int argc,
macro_arguments *argv)
if (msg != NULL)
{
m4_warn (0, me, _("bad regular expression %s: %s"),
- quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)),
- msg);
+ quotearg_style_mem (locale_quoting_style, regexp, ARG_LEN (2)),
+ msg);
return;
}
@@ -2468,43 +2468,43 @@ m4_patsubst (struct obstack *obs, int argc,
macro_arguments *argv)
while (offset <= length)
{
matchpos = re_search (buf, victim, length,
- offset, length - offset, regs);
+ offset, length - offset, regs);
if (matchpos < 0)
- {
+ {
- /* Match failed -- either error or there is no match in the
- rest of the string, in which case the rest of the string is
- copied verbatim. */
+ /* Match failed -- either error or there is no match in the
+ rest of the string, in which case the rest of the string is
+ copied verbatim. */
- if (matchpos == -2)
- m4_warn (0, me, _("problem matching regular expression %s"),
- quotearg_style_mem (locale_quoting_style, regexp,
- ARG_LEN (2)));
- else if (offset < length)
- obstack_grow (obs, victim + offset, length - offset);
- break;
- }
+ if (matchpos == -2)
+ m4_warn (0, me, _("problem matching regular expression %s"),
+ quotearg_style_mem (locale_quoting_style, regexp,
+ ARG_LEN (2)));
+ else if (offset < length)
+ obstack_grow (obs, victim + offset, length - offset);
+ break;
+ }
/* Copy the part of the string that was skipped by re_search (). */
if (matchpos > offset)
- obstack_grow (obs, victim + offset, matchpos - offset);
+ obstack_grow (obs, victim + offset, matchpos - offset);
/* Handle the part of the string that was covered by the match. */
substitute (obs, me, victim, repl, repl_len, regs);
/* Update the offset to the end of the match. If the regexp
- matched a null string, advance offset one more, to avoid
- infinite loops. */
+ matched a null string, advance offset one more, to avoid
+ infinite loops. */
offset = regs->end[0];
if (regs->start[0] == regs->end[0])
- {
- if (offset < length)
- obstack_1grow (obs, victim[offset]);
- offset++;
- }
+ {
+ if (offset < length)
+ obstack_1grow (obs, victim[offset]);
+ offset++;
+ }
}
}
@@ -2525,10 +2525,10 @@ m4_patsubst (struct obstack *obs, int argc,
macro_arguments *argv)
void
m4_placeholder (struct obstack *obs M4_GNUC_UNUSED, int argc M4_GNUC_UNUSED,
- macro_arguments *argv)
+ macro_arguments *argv)
{
m4_warn (0, NULL, _("builtin %s requested by frozen file not found"),
- quotearg_style_mem (locale_quoting_style, ARG (0), ARG_LEN (0)));
+ quotearg_style_mem (locale_quoting_style, ARG (0), ARG_LEN (0)));
}
/*-------------------------------------------------------------------------.
@@ -2541,7 +2541,7 @@ m4_placeholder (struct obstack *obs M4_GNUC_UNUSED, int
argc M4_GNUC_UNUSED,
void
expand_user_macro (struct obstack *obs, symbol *sym,
- int argc, macro_arguments *argv)
+ int argc, macro_arguments *argv)
{
const char *text = SYMBOL_TEXT (sym);
size_t len = SYMBOL_TEXT_LEN (sym);
@@ -2550,52 +2550,52 @@ expand_user_macro (struct obstack *obs, symbol *sym,
{
const char *dollar = (char *) memchr (text, '$', len);
if (!dollar)
- {
- obstack_grow (obs, text, len);
- return;
- }
+ {
+ obstack_grow (obs, text, len);
+ return;
+ }
obstack_grow (obs, text, dollar - text);
len -= dollar - text;
text = dollar;
if (len == 1)
- {
- obstack_1grow (obs, '$');
- return;
- }
+ {
+ obstack_1grow (obs, '$');
+ return;
+ }
len--;
switch (*++text)
- {
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- if (no_gnu_extensions)
- {
- i = *text++ - '0';
- len--;
- }
- else
- {
- for (i = 0; len && isdigit (to_uchar (*text)); text++, len--)
- i = i * 10 + (*text - '0');
- }
- push_arg (obs, argv, i);
- break;
-
- case '#': /* number of arguments */
- shipout_int (obs, argc - 1);
- text++;
- len--;
- break;
-
- case '*': /* all arguments */
- case '@': /* ... same, but quoted */
- push_args (obs, argv, false, *text == '@');
- text++;
- len--;
- break;
-
- default:
- obstack_1grow (obs, '$');
- break;
- }
+ {
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ if (no_gnu_extensions)
+ {
+ i = *text++ - '0';
+ len--;
+ }
+ else
+ {
+ for (i = 0; len && isdigit (to_uchar (*text)); text++, len--)
+ i = i * 10 + (*text - '0');
+ }
+ push_arg (obs, argv, i);
+ break;
+
+ case '#': /* number of arguments */
+ shipout_int (obs, argc - 1);
+ text++;
+ len--;
+ break;
+
+ case '*': /* all arguments */
+ case '@': /* ... same, but quoted */
+ push_args (obs, argv, false, *text == '@');
+ text++;
+ len--;
+ break;
+
+ default:
+ obstack_1grow (obs, '$');
+ break;
+ }
}
}
diff --git a/src/debug.c b/src/debug.c
index 24ddcc3..831178b 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -65,70 +65,70 @@ debug_decode (const char *opts, size_t len)
else
{
if (*opts == '-' || *opts == '+')
- {
- len--;
- mode = *opts++;
- }
+ {
+ len--;
+ mode = *opts++;
+ }
for (level = 0; len--; opts++)
- {
- switch (*opts)
- {
- case 'a':
- level |= DEBUG_TRACE_ARGS;
- break;
-
- case 'e':
- level |= DEBUG_TRACE_EXPANSION;
- break;
-
- case 'q':
- level |= DEBUG_TRACE_QUOTE;
- break;
-
- case 't':
- level |= DEBUG_TRACE_ALL;
- break;
-
- case 'l':
- level |= DEBUG_TRACE_LINE;
- break;
-
- case 'f':
- level |= DEBUG_TRACE_FILE;
- break;
-
- case 'p':
- level |= DEBUG_TRACE_PATH;
- break;
-
- case 'c':
- level |= DEBUG_TRACE_CALL;
- break;
-
- case 'i':
- level |= DEBUG_TRACE_INPUT;
- break;
-
- case 'x':
- level |= DEBUG_TRACE_CALLID;
- break;
-
- case 'd':
- level |= DEBUG_TRACE_DEREF;
- break;
-
- case 'o':
- level |= DEBUG_TRACE_OUTPUT_DUMPDEF;
- break;
-
- case 'V':
- level |= DEBUG_TRACE_VERBOSE;
- break;
-
- default:
- return -1;
- }
- }
+ {
+ switch (*opts)
+ {
+ case 'a':
+ level |= DEBUG_TRACE_ARGS;
+ break;
+
+ case 'e':
+ level |= DEBUG_TRACE_EXPANSION;
+ break;
+
+ case 'q':
+ level |= DEBUG_TRACE_QUOTE;
+ break;
+
+ case 't':
+ level |= DEBUG_TRACE_ALL;
+ break;
+
+ case 'l':
+ level |= DEBUG_TRACE_LINE;
+ break;
+
+ case 'f':
+ level |= DEBUG_TRACE_FILE;
+ break;
+
+ case 'p':
+ level |= DEBUG_TRACE_PATH;
+ break;
+
+ case 'c':
+ level |= DEBUG_TRACE_CALL;
+ break;
+
+ case 'i':
+ level |= DEBUG_TRACE_INPUT;
+ break;
+
+ case 'x':
+ level |= DEBUG_TRACE_CALLID;
+ break;
+
+ case 'd':
+ level |= DEBUG_TRACE_DEREF;
+ break;
+
+ case 'o':
+ level |= DEBUG_TRACE_OUTPUT_DUMPDEF;
+ break;
+
+ case 'V':
+ level |= DEBUG_TRACE_VERBOSE;
+ break;
+
+ default:
+ return -1;
+ }
+ }
}
switch (mode)
{
@@ -174,20 +174,20 @@ debug_set_file (const call_info *caller, FILE *fp)
if (debug != NULL && debug != stdout)
{
if (fstat (STDOUT_FILENO, &stdout_stat) < 0)
- return;
+ return;
if (fstat (fileno (debug), &debug_stat) < 0)
- return;
+ return;
/* mingw has a bug where fstat on a regular file reports st_ino
- of 0. On normal system, st_ino should never be 0. */
+ of 0. On normal system, st_ino should never be 0. */
if (stdout_stat.st_ino == debug_stat.st_ino
- && stdout_stat.st_dev == debug_stat.st_dev
- && stdout_stat.st_ino != 0)
- {
- if (debug != stderr && close_stream (debug) != 0)
- m4_error (0, errno, caller, _("error writing to debug stream"));
- debug = stdout;
- }
+ && stdout_stat.st_dev == debug_stat.st_dev
+ && stdout_stat.st_ino != 0)
+ {
+ if (debug != stderr && close_stream (debug) != 0)
+ m4_error (0, errno, caller, _("error writing to debug stream"));
+ debug = stdout;
+ }
}
}
@@ -242,10 +242,10 @@ debug_set_output (const call_info *caller, const char
*name)
{
fp = fopen (name, "a");
if (fp == NULL)
- return false;
+ return false;
if (set_cloexec_flag (fileno (fp), true) != 0)
- m4_warn (errno, caller, _("cannot protect debug file across forks"));
+ m4_warn (errno, caller, _("cannot protect debug file across forks"));
debug_set_file (caller, fp);
}
return true;
@@ -263,12 +263,12 @@ debug_message (const char *format, ...)
{
xfprintf (debug, "m4debug:");
if (current_line)
- {
- if (debug_level & DEBUG_TRACE_FILE)
- xfprintf (debug, "%s:", current_file);
- if (debug_level & DEBUG_TRACE_LINE)
- xfprintf (debug, "%d:", current_line);
- }
+ {
+ if (debug_level & DEBUG_TRACE_FILE)
+ xfprintf (debug, "%s:", current_file);
+ if (debug_level & DEBUG_TRACE_LINE)
+ xfprintf (debug, "%d:", current_line);
+ }
putc (' ', debug);
va_start (args, format);
xvfprintf (debug, format, args);
@@ -364,8 +364,8 @@ trace_pre (macro_arguments *argv)
size_t len = max_debug_argument_length;
obstack_1grow (&trace, '(');
arg_print (&trace, argv, 1,
- (trace_level & DEBUG_TRACE_QUOTE) ? &curr_quote : NULL,
- false, NULL, ", ", &len, true);
+ (trace_level & DEBUG_TRACE_QUOTE) ? &curr_quote : NULL,
+ false, NULL, ", ", &len, true);
obstack_1grow (&trace, ')');
}
return start;
@@ -385,10 +385,10 @@ trace_post (unsigned int start, const call_info *info)
{
obstack_grow (&trace, " -> ", 4);
if (info->debug_level & DEBUG_TRACE_QUOTE)
- obstack_grow (&trace, curr_quote.str1, curr_quote.len1);
+ obstack_grow (&trace, curr_quote.str1, curr_quote.len1);
input_print (&trace);
if (info->debug_level & DEBUG_TRACE_QUOTE)
- obstack_grow (&trace, curr_quote.str2, curr_quote.len2);
+ obstack_grow (&trace, curr_quote.str2, curr_quote.len2);
}
trace_flush (start);
}
diff --git a/src/eval.c b/src/eval.c
index 671b690..19b74d4 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -127,67 +127,67 @@ eval_lex (int32_t *val)
int base, digit;
if (*eval_text == '0')
- {
- eval_text++;
- switch (*eval_text)
- {
- case 'x':
- case 'X':
- base = 16;
- eval_text++;
- break;
-
- case 'b':
- case 'B':
- base = 2;
- eval_text++;
- break;
-
- case 'r':
- case 'R':
- base = 0;
- eval_text++;
- while (isdigit (to_uchar (*eval_text)) && base <= 36)
- base = 10 * base + *eval_text++ - '0';
- if (base == 0 || base > 36 || *eval_text != ':')
- return ERROR;
- eval_text++;
- break;
-
- default:
- base = 8;
- }
- }
+ {
+ eval_text++;
+ switch (*eval_text)
+ {
+ case 'x':
+ case 'X':
+ base = 16;
+ eval_text++;
+ break;
+
+ case 'b':
+ case 'B':
+ base = 2;
+ eval_text++;
+ break;
+
+ case 'r':
+ case 'R':
+ base = 0;
+ eval_text++;
+ while (isdigit (to_uchar (*eval_text)) && base <= 36)
+ base = 10 * base + *eval_text++ - '0';
+ if (base == 0 || base > 36 || *eval_text != ':')
+ return ERROR;
+ eval_text++;
+ break;
+
+ default:
+ base = 8;
+ }
+ }
else
- base = 10;
+ base = 10;
/* FIXME - this calculation can overflow. Consider xstrtol. */
*val = 0;
for (; *eval_text; eval_text++)
- {
- if (isdigit (to_uchar (*eval_text)))
- digit = *eval_text - '0';
- else if (islower (to_uchar (*eval_text)))
- digit = *eval_text - 'a' + 10;
- else if (isupper (to_uchar (*eval_text)))
- digit = *eval_text - 'A' + 10;
- else
- break;
-
- if (base == 1)
- {
- if (digit == 1)
- (*val)++;
- else if (digit == 0 && !*val)
- continue;
- else
- break;
- }
- else if (digit >= base)
- break;
- else
- *val = *val * base + digit;
- }
+ {
+ if (isdigit (to_uchar (*eval_text)))
+ digit = *eval_text - '0';
+ else if (islower (to_uchar (*eval_text)))
+ digit = *eval_text - 'a' + 10;
+ else if (isupper (to_uchar (*eval_text)))
+ digit = *eval_text - 'A' + 10;
+ else
+ break;
+
+ if (base == 1)
+ {
+ if (digit == 1)
+ (*val)++;
+ else if (digit == 0 && !*val)
+ continue;
+ else
+ break;
+ }
+ else if (digit >= base)
+ break;
+ else
+ *val = *val * base + digit;
+ }
return NUMBER;
}
@@ -195,92 +195,92 @@ eval_lex (int32_t *val)
{
case '+':
if (*eval_text == '+' || *eval_text == '=')
- return BADOP;
+ return BADOP;
return PLUS;
case '-':
if (*eval_text == '-' || *eval_text == '=')
- return BADOP;
+ return BADOP;
return MINUS;
case '*':
if (*eval_text == '*')
- {
- eval_text++;
- return EXPONENT;
- }
+ {
+ eval_text++;
+ return EXPONENT;
+ }
else if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return TIMES;
case '/':
if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return DIVIDE;
case '%':
if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return MODULO;
case '=':
if (*eval_text == '=')
- {
- eval_text++;
- return EQ;
- }
+ {
+ eval_text++;
+ return EQ;
+ }
return ASSIGN;
case '!':
if (*eval_text == '=')
- {
- eval_text++;
- return NOTEQ;
- }
+ {
+ eval_text++;
+ return NOTEQ;
+ }
return LNOT;
case '>':
if (*eval_text == '=')
- {
- eval_text++;
- return GTEQ;
- }
+ {
+ eval_text++;
+ return GTEQ;
+ }
else if (*eval_text == '>')
- {
- if (*++eval_text == '=')
- return BADOP;
- return RSHIFT;
- }
+ {
+ if (*++eval_text == '=')
+ return BADOP;
+ return RSHIFT;
+ }
return GT;
case '<':
if (*eval_text == '=')
- {
- eval_text++;
- return LSEQ;
- }
+ {
+ eval_text++;
+ return LSEQ;
+ }
else if (*eval_text == '<')
- {
- if (*++eval_text == '=')
- return BADOP;
- return LSHIFT;
- }
+ {
+ if (*++eval_text == '=')
+ return BADOP;
+ return LSHIFT;
+ }
return LS;
case '^':
if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return XOR;
case '~':
return NOT;
case '&':
if (*eval_text == '&')
- {
- eval_text++;
- return LAND;
- }
+ {
+ eval_text++;
+ return LAND;
+ }
else if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return AND;
case '|':
if (*eval_text == '|')
- {
- eval_text++;
- return LOR;
- }
+ {
+ eval_text++;
+ return LOR;
+ }
else if (*eval_text == '=')
- return BADOP;
+ return BADOP;
return OR;
case '(':
return LEFTP;
@@ -315,9 +315,9 @@ evaluate (const call_info *me, const char *expr, size_t
len, int32_t *val)
if (err == NO_ERROR && *eval_text != '\0')
{
if (eval_lex (val) == BADOP)
- err = INVALID_OPERATOR;
+ err = INVALID_OPERATOR;
else
- err = EXCESS_INPUT;
+ err = EXCESS_INPUT;
}
if (err != NO_ERROR)
@@ -395,31 +395,31 @@ condition_term (const call_info *me, eval_token et,
int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
/* Implement short-circuiting of valid syntax. */
/* C requires 'logical_or_term ? expression : condition_term';
- if we ever introduce assignment_term or comma_term, then
- condition_term and expression are no longer synonymous. */
+ if we ever introduce assignment_term or comma_term, then
+ condition_term and expression are no longer synonymous. */
er = condition_term (me, et, &v2);
if (er != NO_ERROR
- && !(*v1 == 0 && er < SYNTAX_ERROR))
- return er;
+ && !(*v1 == 0 && er < SYNTAX_ERROR))
+ return er;
et = eval_lex (&v3);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if (et != COLON)
- return MISSING_COLON;
+ return MISSING_COLON;
et = eval_lex (&v3);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
er = condition_term (me, et, &v3);
if (er != NO_ERROR
- && !(*v1 != 0 && er < SYNTAX_ERROR))
- return er;
+ && !(*v1 != 0 && er < SYNTAX_ERROR))
+ return er;
*v1 = *v1 ? v2 : v3;
}
@@ -443,16 +443,16 @@ logical_or_term (const call_info *me, eval_token et,
int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
/* Implement short-circuiting of valid syntax. */
er = logical_and_term (me, et, &v2);
if (er == NO_ERROR)
- *v1 = *v1 || v2;
+ *v1 = *v1 || v2;
else if (*v1 != 0 && er < SYNTAX_ERROR)
- *v1 = 1;
+ *v1 = 1;
else
- return er;
+ return er;
}
if (et == ERROR)
return UNKNOWN_INPUT;
@@ -474,16 +474,16 @@ logical_and_term (const call_info *me, eval_token et,
int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
/* Implement short-circuiting of valid syntax. */
er = or_term (me, et, &v2);
if (er == NO_ERROR)
- *v1 = *v1 && v2;
+ *v1 = *v1 && v2;
else if (*v1 == 0 && er < SYNTAX_ERROR)
- ; /* v1 is already 0 */
+ ; /* v1 is already 0 */
else
- return er;
+ return er;
}
if (et == ERROR)
return UNKNOWN_INPUT;
@@ -505,10 +505,10 @@ or_term (const call_info *me, eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = xor_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 |= v2;
}
@@ -532,10 +532,10 @@ xor_term (const call_info *me, eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = and_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 ^= v2;
}
@@ -559,10 +559,10 @@ and_term (const call_info *me, eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = equality_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 &= v2;
}
@@ -590,15 +590,15 @@ equality_term (const call_info *me, eval_token et,
int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = cmp_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
if (op == ASSIGN)
{
- m4_warn (0, me, _("recommend ==, not =, for equality"));
- op = EQ;
+ m4_warn (0, me, _("recommend ==, not =, for equality"));
+ op = EQ;
}
*v1 = (op == EQ) == (*v1 == v2);
}
@@ -620,38 +620,38 @@ cmp_term (const call_info *me, eval_token et, int32_t *v1)
return er;
while ((op = eval_lex (&v2)) == GT || op == GTEQ
- || op == LS || op == LSEQ)
+ || op == LS || op == LSEQ)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = shift_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
switch (op)
- {
- case GT:
- *v1 = *v1 > v2;
- break;
-
- case GTEQ:
- *v1 = *v1 >= v2;
- break;
-
- case LS:
- *v1 = *v1 < v2;
- break;
-
- case LSEQ:
- *v1 = *v1 <= v2;
- break;
-
- default:
- assert (!"cmp_term");
- abort ();
- }
+ {
+ case GT:
+ *v1 = *v1 > v2;
+ break;
+
+ case GTEQ:
+ *v1 = *v1 >= v2;
+ break;
+
+ case LS:
+ *v1 = *v1 < v2;
+ break;
+
+ case LSEQ:
+ *v1 = *v1 <= v2;
+ break;
+
+ default:
+ assert (!"cmp_term");
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -676,35 +676,35 @@ shift_term (const call_info *me, eval_token et, int32_t
*v1)
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = add_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
/* Minimize undefined C behavior (shifting by a negative number,
- shifting by the width or greater, left shift overflow, or
- right shift of a negative number). Implement Java 32-bit
- wrap-around semantics. This code assumes that the
- implementation-defined overflow when casting unsigned to
- signed is a silent twos-complement wrap-around. */
+ shifting by the width or greater, left shift overflow, or
+ right shift of a negative number). Implement Java 32-bit
+ wrap-around semantics. This code assumes that the
+ implementation-defined overflow when casting unsigned to
+ signed is a silent twos-complement wrap-around. */
switch (op)
- {
- case LSHIFT:
- u1 = *v1;
- u1 <<= (uint32_t) (v2 & 0x1f);
- *v1 = u1;
- break;
-
- case RSHIFT:
- u1 = *v1 < 0 ? ~*v1 : *v1;
- u1 >>= (uint32_t) (v2 & 0x1f);
- *v1 = *v1 < 0 ? ~u1 : u1;
- break;
-
- default:
- assert (!"shift_term");
- abort ();
- }
+ {
+ case LSHIFT:
+ u1 = *v1;
+ u1 <<= (uint32_t) (v2 & 0x1f);
+ *v1 = u1;
+ break;
+
+ case RSHIFT:
+ u1 = *v1 < 0 ? ~*v1 : *v1;
+ u1 >>= (uint32_t) (v2 & 0x1f);
+ *v1 = *v1 < 0 ? ~u1 : u1;
+ break;
+
+ default:
+ assert (!"shift_term");
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -727,19 +727,19 @@ add_term (const call_info *me, eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = mult_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
/* Minimize undefined C behavior on overflow. This code assumes
- that the implementation-defined overflow when casting
- unsigned to signed is a silent twos-complement
- wrap-around. */
+ that the implementation-defined overflow when casting
+ unsigned to signed is a silent twos-complement
+ wrap-around. */
if (op == PLUS)
- *v1 = (int32_t) ((uint32_t) *v1 + (uint32_t) v2);
+ *v1 = (int32_t) ((uint32_t) *v1 + (uint32_t) v2);
else
- *v1 = (int32_t) ((uint32_t) *v1 - (uint32_t) v2);
+ *v1 = (int32_t) ((uint32_t) *v1 - (uint32_t) v2);
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -762,45 +762,45 @@ mult_term (const call_info *me, eval_token et, int32_t
*v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = exp_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
/* Minimize undefined C behavior on overflow. This code assumes
- that the implementation-defined overflow when casting
- unsigned to signed is a silent twos-complement
- wrap-around. */
+ that the implementation-defined overflow when casting
+ unsigned to signed is a silent twos-complement
+ wrap-around. */
switch (op)
- {
- case TIMES:
- *v1 = (int32_t) ((uint32_t) *v1 * (uint32_t) v2);
- break;
-
- case DIVIDE:
- if (v2 == 0)
- return DIVIDE_ZERO;
- else if (v2 == -1)
- /* Avoid overflow, and the x86 SIGFPE on INT_MIN / -1. */
- *v1 = (int32_t) -(uint32_t) *v1;
- else
- *v1 /= v2;
- break;
-
- case MODULO:
- if (v2 == 0)
- return MODULO_ZERO;
- else if (v2 == -1)
- /* Avoid the x86 SIGFPE on INT_MIN % -1. */
- *v1 = 0;
- else
- *v1 %= v2;
- break;
-
- default:
- assert (!"mult_term");
- abort ();
- }
+ {
+ case TIMES:
+ *v1 = (int32_t) ((uint32_t) *v1 * (uint32_t) v2);
+ break;
+
+ case DIVIDE:
+ if (v2 == 0)
+ return DIVIDE_ZERO;
+ else if (v2 == -1)
+ /* Avoid overflow, and the x86 SIGFPE on INT_MIN / -1. */
+ *v1 = (int32_t) -(uint32_t) *v1;
+ else
+ *v1 /= v2;
+ break;
+
+ case MODULO:
+ if (v2 == 0)
+ return MODULO_ZERO;
+ else if (v2 == -1)
+ /* Avoid the x86 SIGFPE on INT_MIN % -1. */
+ *v1 = 0;
+ else
+ *v1 %= v2;
+ break;
+
+ default:
+ assert (!"mult_term");
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -823,22 +823,22 @@ exp_term (const call_info *me, eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = exp_term (me, et, &v2)) != NO_ERROR)
- return er;
+ return er;
/* Minimize undefined C behavior on overflow. This code assumes
- that the implementation-defined overflow when casting
- unsigned to signed is a silent twos-complement
- wrap-around. */
+ that the implementation-defined overflow when casting
+ unsigned to signed is a silent twos-complement
+ wrap-around. */
result = 1;
if (v2 < 0)
- return NEGATIVE_EXPONENT;
+ return NEGATIVE_EXPONENT;
if (*v1 == 0 && v2 == 0)
- return DIVIDE_ZERO;
+ return DIVIDE_ZERO;
while (v2-- > 0)
- result *= (uint32_t) *v1;
+ result *= (uint32_t) *v1;
*v1 = result;
}
if (et == ERROR)
@@ -858,21 +858,21 @@ unary_term (const call_info *me, eval_token et, int32_t
*v1)
{
et2 = eval_lex (v1);
if (et2 == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = unary_term (me, et2, v1)) != NO_ERROR)
- return er;
+ return er;
/* Minimize undefined C behavior on overflow. This code assumes
- that the implementation-defined overflow when casting
- unsigned to signed is a silent twos-complement
- wrap-around. */
+ that the implementation-defined overflow when casting
+ unsigned to signed is a silent twos-complement
+ wrap-around. */
if (et == MINUS)
- *v1 = (int32_t) -(uint32_t) *v1;
+ *v1 = (int32_t) -(uint32_t) *v1;
else if (et == NOT)
- *v1 = ~*v1;
+ *v1 = ~*v1;
else if (et == LNOT)
- *v1 = *v1 == 0 ? 1 : 0;
+ *v1 = *v1 == 0 ? 1 : 0;
}
else if ((er = simple_term (me, et, v1)) != NO_ERROR)
return er;
@@ -891,17 +891,17 @@ simple_term (const call_info *me, eval_token et, int32_t
*v1)
case LEFTP:
et = eval_lex (v1);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = condition_term (me, et, v1)) != NO_ERROR)
- return er;
+ return er;
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if (et != RIGHTP)
- return MISSING_RIGHT;
+ return MISSING_RIGHT;
break;
diff --git a/src/format.c b/src/format.c
index 6b62629..7ebae7f 100644
--- a/src/format.c
+++ b/src/format.c
@@ -46,7 +46,7 @@ arg_int (const call_info *me, const char *str, size_t len)
value = strtol (str, &endp, 10);
if (endp - str - len)
m4_warn (0, me, _("non-numeric argument %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ quotearg_style_mem (locale_quoting_style, str, len));
else if (isspace (to_uchar (*str)))
m4_warn (0, me, _("leading whitespace ignored"));
else if (errno == ERANGE || (int) value != value)
@@ -73,7 +73,7 @@ arg_long (const call_info *me, const char *str, size_t len)
value = strtol (str, &endp, 10);
if (endp - str - len)
m4_warn (0, me, _("non-numeric argument %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ quotearg_style_mem (locale_quoting_style, str, len));
else if (isspace (to_uchar (*str)))
m4_warn (0, me, _("leading whitespace ignored"));
else if (errno == ERANGE)
@@ -88,7 +88,7 @@ arg_string (const call_info *me, const char *str, size_t len)
{
if (strlen (str) < len)
m4_warn (0, me, _("argument %s truncated"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ quotearg_style_mem (locale_quoting_style, str, len));
return str;
}
@@ -109,7 +109,7 @@ arg_double (const call_info *me, const char *str, size_t
len)
value = strtod (str, &endp);
if (endp - str - len)
m4_warn (0, me, _("non-numeric argument %s"),
- quotearg_style_mem (locale_quoting_style, str, len));
+ quotearg_style_mem (locale_quoting_style, str, len));
else if (isspace (to_uchar (*str)))
m4_warn (0, me, _("leading whitespace ignored"));
else if (errno == ERANGE)
@@ -185,233 +185,233 @@ expand_format (struct obstack *obs, int argc,
macro_arguments *argv)
{
const char *percent = (char *) memchr (fmt, '%', f_len);
if (!percent)
- {
- obstack_grow (obs, fmt, f_len);
- break;
- }
+ {
+ obstack_grow (obs, fmt, f_len);
+ break;
+ }
obstack_grow (obs, fmt, percent - fmt);
f_len -= percent - fmt + 1;
fmt = percent + 1;
if (*fmt == '%')
- {
- obstack_1grow (obs, '%');
- fmt++;
- f_len--;
- continue;
- }
+ {
+ obstack_1grow (obs, '%');
+ fmt++;
+ f_len--;
+ continue;
+ }
p = fstart + 1; /* % */
lflag = 0;
ok['a'] = ok['A'] = ok['c'] = ok['d'] = ok['e'] = ok['E']
- = ok['f'] = ok['F'] = ok['g'] = ok['G'] = ok['i'] = ok['o']
- = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 1;
+ = ok['f'] = ok['F'] = ok['g'] = ok['G'] = ok['i'] = ok['o']
+ = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 1;
/* Parse flags. */
flags = 0;
do
- {
- switch (*fmt)
- {
- case '\'': /* thousands separator */
- ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E']
- = ok['o'] = ok['s'] = ok['x'] = ok['X'] = 0;
- flags |= THOUSANDS;
- break;
-
- case '+': /* mandatory sign */
- ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0;
- flags |= PLUS;
- break;
-
- case ' ': /* space instead of positive sign */
- ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0;
- flags |= SPACE;
- break;
-
- case '0': /* zero padding */
- ok['c'] = ok['s'] = 0;
- flags |= ZERO;
- break;
-
- case '#': /* alternate output */
- ok['c'] = ok['d'] = ok['i'] = ok['s'] = ok['u'] = 0;
- flags |= ALT;
- break;
-
- case '-': /* left justification */
- flags |= MINUS;
- break;
-
- default:
- flags |= DONE;
- break;
- }
- }
+ {
+ switch (*fmt)
+ {
+ case '\'': /* thousands separator */
+ ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E']
+ = ok['o'] = ok['s'] = ok['x'] = ok['X'] = 0;
+ flags |= THOUSANDS;
+ break;
+
+ case '+': /* mandatory sign */
+ ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0;
+ flags |= PLUS;
+ break;
+
+ case ' ': /* space instead of positive sign */
+ ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0;
+ flags |= SPACE;
+ break;
+
+ case '0': /* zero padding */
+ ok['c'] = ok['s'] = 0;
+ flags |= ZERO;
+ break;
+
+ case '#': /* alternate output */
+ ok['c'] = ok['d'] = ok['i'] = ok['s'] = ok['u'] = 0;
+ flags |= ALT;
+ break;
+
+ case '-': /* left justification */
+ flags |= MINUS;
+ break;
+
+ default:
+ flags |= DONE;
+ break;
+ }
+ }
while (!(flags & DONE) && (f_len--, fmt++));
if (flags & THOUSANDS)
- *p++ = '\'';
+ *p++ = '\'';
if (flags & PLUS)
- *p++ = '+';
+ *p++ = '+';
if (flags & MINUS)
- *p++ = '-';
+ *p++ = '-';
if (flags & SPACE)
- *p++ = ' ';
+ *p++ = ' ';
if (flags & ZERO)
- *p++ = '0';
+ *p++ = '0';
if (flags & ALT)
- *p++ = '#';
+ *p++ = '#';
/* Minimum field width; an explicit 0 is the same as not giving
- the width. */
+ the width. */
width = 0;
*p++ = '*';
if (*fmt == '*')
- {
- width = ARG_INT (i, argc, argv);
- fmt++;
- f_len--;
- }
+ {
+ width = ARG_INT (i, argc, argv);
+ fmt++;
+ f_len--;
+ }
else
- while (isdigit (to_uchar (*fmt)))
- {
- width = 10 * width + *fmt - '0';
- fmt++;
- f_len--;
- }
+ while (isdigit (to_uchar (*fmt)))
+ {
+ width = 10 * width + *fmt - '0';
+ fmt++;
+ f_len--;
+ }
/* Maximum precision; an explicit negative precision is the same
- as not giving the precision. A lone '.' is a precision of 0. */
+ as not giving the precision. A lone '.' is a precision of 0. */
prec = -1;
*p++ = '.';
*p++ = '*';
if (*fmt == '.')
- {
- ok['c'] = 0;
- f_len--;
- if (*(++fmt) == '*')
- {
- prec = ARG_INT (i, argc, argv);
- ++fmt;
- f_len--;
- }
- else
- {
- prec = 0;
- while (isdigit (to_uchar (*fmt)))
- {
- prec = 10 * prec + *fmt - '0';
- fmt++;
- f_len--;
- }
- }
- }
+ {
+ ok['c'] = 0;
+ f_len--;
+ if (*(++fmt) == '*')
+ {
+ prec = ARG_INT (i, argc, argv);
+ ++fmt;
+ f_len--;
+ }
+ else
+ {
+ prec = 0;
+ while (isdigit (to_uchar (*fmt)))
+ {
+ prec = 10 * prec + *fmt - '0';
+ fmt++;
+ f_len--;
+ }
+ }
+ }
/* Length modifiers. We don't yet recognize ll, j, t, or z. */
if (*fmt == 'l')
- {
- *p++ = 'l';
- lflag = 1;
- fmt++;
- f_len--;
- ok['c'] = ok['s'] = 0;
- }
+ {
+ *p++ = 'l';
+ lflag = 1;
+ fmt++;
+ f_len--;
+ ok['c'] = ok['s'] = 0;
+ }
else if (*fmt == 'h')
- {
- *p++ = 'h';
- fmt++;
- f_len--;
- if (*fmt == 'h')
- {
- *p++ = 'h';
- fmt++;
- f_len--;
- }
- ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E'] = ok['f'] = ok['F']
- = ok['g'] = ok['G'] = ok['s'] = 0;
- }
+ {
+ *p++ = 'h';
+ fmt++;
+ f_len--;
+ if (*fmt == 'h')
+ {
+ *p++ = 'h';
+ fmt++;
+ f_len--;
+ }
+ ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E'] = ok['f'] = ok['F']
+ = ok['g'] = ok['G'] = ok['s'] = 0;
+ }
c = *fmt;
if (c > sizeof ok || !ok[c] || !f_len)
- {
- m4_warn (0, me, _("unrecognized specifier in %s"),
- quotearg_style_mem (locale_quoting_style, f, ARG_LEN (1)));
- valid_format = false;
- continue;
- }
+ {
+ m4_warn (0, me, _("unrecognized specifier in %s"),
+ quotearg_style_mem (locale_quoting_style, f, ARG_LEN (1)));
+ valid_format = false;
+ continue;
+ }
fmt++;
f_len--;
/* Specifiers. We don't yet recognize C, S, n, or p. */
switch (c)
- {
- case 'c':
- datatype = CHAR;
- p -= 2; /* %.*c is undefined, so undo the '.*'. */
- break;
-
- case 's':
- datatype = STR;
- break;
-
- case 'd':
- case 'i':
- case 'o':
- case 'x':
- case 'X':
- case 'u':
- datatype = lflag ? LONG : INT;
- break;
-
- case 'a':
- case 'A':
- case 'e':
- case 'E':
- case 'f':
- case 'F':
- case 'g':
- case 'G':
- datatype = DOUBLE;
- break;
-
- default:
- abort ();
- }
+ {
+ case 'c':
+ datatype = CHAR;
+ p -= 2; /* %.*c is undefined, so undo the '.*'. */
+ break;
+
+ case 's':
+ datatype = STR;
+ break;
+
+ case 'd':
+ case 'i':
+ case 'o':
+ case 'x':
+ case 'X':
+ case 'u':
+ datatype = lflag ? LONG : INT;
+ break;
+
+ case 'a':
+ case 'A':
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'F':
+ case 'g':
+ case 'G':
+ datatype = DOUBLE;
+ break;
+
+ default:
+ abort ();
+ }
*p++ = c;
*p = '\0';
switch (datatype)
- {
- case CHAR:
- result = obstack_printf (obs, fstart, width,
- ARG_INT (i, argc, argv));
- break;
-
- case INT:
- result = obstack_printf (obs, fstart, width, prec,
- ARG_INT (i, argc, argv));
- break;
-
- case LONG:
- result = obstack_printf (obs, fstart, width, prec,
- ARG_LONG (i, argc, argv));
- break;
-
- case DOUBLE:
- result = obstack_printf (obs, fstart, width, prec,
- ARG_DOUBLE (i, argc, argv));
- break;
-
- case STR:
- result = obstack_printf (obs, fstart, width, prec,
- ARG_STR (i, argc, argv));
- break;
-
- default:
- abort ();
- }
+ {
+ case CHAR:
+ result = obstack_printf (obs, fstart, width,
+ ARG_INT (i, argc, argv));
+ break;
+
+ case INT:
+ result = obstack_printf (obs, fstart, width, prec,
+ ARG_INT (i, argc, argv));
+ break;
+
+ case LONG:
+ result = obstack_printf (obs, fstart, width, prec,
+ ARG_LONG (i, argc, argv));
+ break;
+
+ case DOUBLE:
+ result = obstack_printf (obs, fstart, width, prec,
+ ARG_DOUBLE (i, argc, argv));
+ break;
+
+ case STR:
+ result = obstack_printf (obs, fstart, width, prec,
+ ARG_STR (i, argc, argv));
+ break;
+
+ default:
+ abort ();
+ }
/* Since obstack_printf can only fail with EILSEQ or EINVAL, but
- we constructed fstart, the result should not be negative. */
+ we constructed fstart, the result should not be negative. */
assert (0 <= result);
}
if (valid_format)
diff --git a/src/freeze.c b/src/freeze.c
index 8e790c1..d4e3989 100644
--- a/src/freeze.c
+++ b/src/freeze.c
@@ -71,40 +71,40 @@ dump_symbol_CB (symbol *sym, void *f)
do
{
switch (SYMBOL_TYPE (sym))
- {
- case TOKEN_TEXT:
- xfprintf (file, "T%d,%d\n",
- (int) SYMBOL_NAME_LEN (sym),
- (int) SYMBOL_TEXT_LEN (sym));
- xfwrite (SYMBOL_NAME (sym), 1, SYMBOL_NAME_LEN (sym), file);
- xfwrite (SYMBOL_TEXT (sym), 1, SYMBOL_TEXT_LEN (sym), file);
- fputc ('\n', file);
- break;
-
- case TOKEN_FUNC:
- bp = find_builtin_by_addr (SYMBOL_FUNC (sym));
- if (bp == NULL)
- {
- assert (!"dump_symbol_CB");
- abort ();
- }
- xfprintf (file, "F%d,%d\n",
- (int) SYMBOL_NAME_LEN (sym),
- (int) strlen (bp->name));
- xfwrite (SYMBOL_NAME (sym), 1, SYMBOL_NAME_LEN (sym), file);
- fputs (bp->name, file);
- fputc ('\n', file);
- break;
-
- case TOKEN_VOID:
- /* Ignore placeholder tokens that exist due to traceon. */
- break;
-
- default:
- assert (!"dump_symbol_CB");
- abort ();
- break;
- }
+ {
+ case TOKEN_TEXT:
+ xfprintf (file, "T%d,%d\n",
+ (int) SYMBOL_NAME_LEN (sym),
+ (int) SYMBOL_TEXT_LEN (sym));
+ xfwrite (SYMBOL_NAME (sym), 1, SYMBOL_NAME_LEN (sym), file);
+ xfwrite (SYMBOL_TEXT (sym), 1, SYMBOL_TEXT_LEN (sym), file);
+ fputc ('\n', file);
+ break;
+
+ case TOKEN_FUNC:
+ bp = find_builtin_by_addr (SYMBOL_FUNC (sym));
+ if (bp == NULL)
+ {
+ assert (!"dump_symbol_CB");
+ abort ();
+ }
+ xfprintf (file, "F%d,%d\n",
+ (int) SYMBOL_NAME_LEN (sym),
+ (int) strlen (bp->name));
+ xfwrite (SYMBOL_NAME (sym), 1, SYMBOL_NAME_LEN (sym), file);
+ fputs (bp->name, file);
+ fputc ('\n', file);
+ break;
+
+ case TOKEN_VOID:
+ /* Ignore placeholder tokens that exist due to traceon. */
+ break;
+
+ default:
+ assert (!"dump_symbol_CB");
+ abort ();
+ break;
+ }
sym = sym->stack;
}
while (sym != stack->stack);
@@ -125,14 +125,14 @@ produce_frozen_state (const char *name)
if (!file)
{
m4_error (0, errno, NULL, _("cannot open %s"),
- quotearg_style (locale_quoting_style, name));
+ quotearg_style (locale_quoting_style, name));
return;
}
/* Write a recognizable header. */
xfprintf (file, "# This is a frozen state file generated by %s\n",
- PACKAGE_STRING);
+ PACKAGE_STRING);
xfprintf (file, "V1\n");
/* Dump quote delimiters. */
@@ -141,7 +141,7 @@ produce_frozen_state (const char *name)
|| *curr_quote.str1 != *DEF_LQUOTE || *curr_quote.str2 != *DEF_RQUOTE)
{
xfprintf (file, "Q%d,%d\n", (int) curr_quote.len1,
- (int) curr_quote.len2);
+ (int) curr_quote.len2);
xfwrite (curr_quote.str1, 1, curr_quote.len1, file);
xfwrite (curr_quote.str2, 1, curr_quote.len2, file);
fputc ('\n', file);
@@ -153,7 +153,7 @@ produce_frozen_state (const char *name)
|| *curr_comm.str1 != *DEF_BCOMM || *curr_comm.str2 != *DEF_ECOMM)
{
xfprintf (file, "C%d,%d\n", (int) curr_comm.len1,
- (int) curr_comm.len2);
+ (int) curr_comm.len2);
xfwrite (curr_comm.str1, 1, curr_comm.len1, file);
xfwrite (curr_comm.str2, 1, curr_comm.len2, file);
fputc ('\n', file);
@@ -186,7 +186,7 @@ issue_expect_message (int expected)
m4_error (EXIT_FAILURE, 0, NULL, _("expecting line feed in frozen file"));
else
m4_error (EXIT_FAILURE, 0, NULL,
- _("expecting character `%c' in frozen file"), expected);
+ _("expecting character `%c' in frozen file"), expected);
}
/*-------------------------------------------------.
@@ -211,13 +211,13 @@ reload_frozen_state (const char *name)
do \
{ \
if (advance_line) \
- { \
- current_line++; \
- advance_line = false; \
- } \
+ { \
+ current_line++; \
+ advance_line = false; \
+ } \
(character = getc (file)); \
if (character == '\n') \
- advance_line = true; \
+ advance_line = true; \
} \
while (0)
@@ -226,14 +226,14 @@ reload_frozen_state (const char *name)
{ \
unsigned int n = 0; \
while (isdigit (character) && n <= INT_MAX / 10U) \
- { \
- n = 10 * n + character - '0'; \
- GET_CHARACTER; \
- } \
+ { \
+ n = 10 * n + character - '0'; \
+ GET_CHARACTER; \
+ } \
if (((AllowNeg) ? INT_MIN : INT_MAX) + 0U < n \
- || isdigit (character)) \
- m4_error (EXIT_FAILURE, 0, NULL, \
- _("integer overflow in frozen file")); \
+ || isdigit (character)) \
+ m4_error (EXIT_FAILURE, 0, NULL, \
+ _("integer overflow in frozen file")); \
(Number) = n; \
} \
while (0)
@@ -242,7 +242,7 @@ reload_frozen_state (const char *name)
do \
{ \
if (character != (Expected)) \
- issue_expect_message (Expected); \
+ issue_expect_message (Expected); \
} \
while (0)
@@ -254,11 +254,11 @@ reload_frozen_state (const char *name)
{ \
GET_CHARACTER; \
if (character == '#') \
- { \
- while (character != EOF && character != '\n') \
- GET_CHARACTER; \
- VALIDATE ('\n'); \
- } \
+ { \
+ while (character != EOF && character != '\n') \
+ GET_CHARACTER; \
+ VALIDATE ('\n'); \
+ } \
} \
while (character == '\n')
@@ -268,29 +268,29 @@ reload_frozen_state (const char *name)
void *tmp; \
char *p; \
if (number[(i)] + 1 > allocated[(i)]) \
- { \
- free (string[(i)]); \
- allocated[(i)] = number[(i)] + 1; \
- string[(i)] = xcharalloc ((size_t) allocated[(i)]); \
- } \
+ { \
+ free (string[(i)]); \
+ allocated[(i)] = number[(i)] + 1; \
+ string[(i)] = xcharalloc ((size_t) allocated[(i)]); \
+ } \
if (number[(i)] > 0 \
- && !fread (string[(i)], (size_t) number[(i)], 1, file)) \
- m4_error (EXIT_FAILURE, 0, NULL, \
- _("premature end of frozen file")); \
+ && !fread (string[(i)], (size_t) number[(i)], 1, file)) \
+ m4_error (EXIT_FAILURE, 0, NULL, \
+ _("premature end of frozen file")); \
string[(i)][number[(i)]] = '\0'; \
p = string[(i)]; \
while ((tmp = memchr(p, '\n', number[(i)] - (p - string[(i)])))) \
- { \
- current_line++; \
- p = (char *) tmp + 1; \
- } \
+ { \
+ current_line++; \
+ p = (char *) tmp + 1;
\
+ } \
} \
while (0)
file = m4_path_search (name, NULL);
if (file == NULL)
m4_error (EXIT_FAILURE, errno, NULL, _("cannot open %s"),
- quotearg_style (locale_quoting_style, name));
+ quotearg_style (locale_quoting_style, name));
current_file = name;
allocated[0] = 100;
@@ -305,107 +305,107 @@ reload_frozen_state (const char *name)
GET_NUMBER (number[0], false);
if (number[0] > 1)
m4_error (EXIT_MISMATCH, 0, NULL,
- _("frozen file version %d greater than max supported of 1"),
- number[0]);
+ _("frozen file version %d greater than max supported of 1"),
+ number[0]);
else if (number[0] < 1)
m4_error (EXIT_FAILURE, 0, NULL,
- _("ill-formed frozen file, version directive expected"));
+ _("ill-formed frozen file, version directive expected"));
VALIDATE ('\n');
GET_DIRECTIVE;
while (character != EOF)
{
switch (character)
- {
- default:
- m4_error (EXIT_FAILURE, 0, NULL, _("ill-formed frozen file"));
-
- case 'C':
- case 'D':
- case 'F':
- case 'T':
- case 'Q':
- operation = character;
- GET_CHARACTER;
-
- /* Get string lengths. Accept a negative diversion number. */
-
- if (operation == 'D' && character == '-')
- {
- GET_CHARACTER;
- GET_NUMBER (number[0], true);
- number[0] = -number[0];
- }
- else
- GET_NUMBER (number[0], false);
- VALIDATE (',');
- GET_CHARACTER;
- GET_NUMBER (number[1], false);
- VALIDATE ('\n');
-
- if (operation != 'D')
- GET_STRING (0);
- GET_STRING (1);
- GET_CHARACTER;
- VALIDATE ('\n');
-
- /* Act according to operation letter. */
-
- switch (operation)
- {
- case 'C':
-
- /* Change comment strings. */
-
- set_comment (string[0], number[0], string[1], number[1]);
- break;
-
- case 'D':
-
- /* Select a diversion and add a string to it. */
-
- make_diversion (number[0]);
- if (number[1] > 0)
- output_text (string[1], number[1]);
- break;
-
- case 'F':
-
- /* Enter a macro having a builtin function as a
- definition. No builtin contains NUL in the name. */
- if (strlen (string[1]) < number[1] + 0UL)
- m4_error (EXIT_FAILURE, 0, NULL, _("\
+ {
+ default:
+ m4_error (EXIT_FAILURE, 0, NULL, _("ill-formed frozen file"));
+
+ case 'C':
+ case 'D':
+ case 'F':
+ case 'T':
+ case 'Q':
+ operation = character;
+ GET_CHARACTER;
+
+ /* Get string lengths. Accept a negative diversion number. */
+
+ if (operation == 'D' && character == '-')
+ {
+ GET_CHARACTER;
+ GET_NUMBER (number[0], true);
+ number[0] = -number[0];
+ }
+ else
+ GET_NUMBER (number[0], false);
+ VALIDATE (',');
+ GET_CHARACTER;
+ GET_NUMBER (number[1], false);
+ VALIDATE ('\n');
+
+ if (operation != 'D')
+ GET_STRING (0);
+ GET_STRING (1);
+ GET_CHARACTER;
+ VALIDATE ('\n');
+
+ /* Act according to operation letter. */
+
+ switch (operation)
+ {
+ case 'C':
+
+ /* Change comment strings. */
+
+ set_comment (string[0], number[0], string[1], number[1]);
+ break;
+
+ case 'D':
+
+ /* Select a diversion and add a string to it. */
+
+ make_diversion (number[0]);
+ if (number[1] > 0)
+ output_text (string[1], number[1]);
+ break;
+
+ case 'F':
+
+ /* Enter a macro having a builtin function as a
+ definition. No builtin contains NUL in the name. */
+ if (strlen (string[1]) < number[1] + 0UL)
+ m4_error (EXIT_FAILURE, 0, NULL, _("\
ill-formed frozen file, invalid builtin %s encountered"),
- quotearg_style_mem (locale_quoting_style, string[1],
- number[1]));
- bp = find_builtin_by_name (string[1]);
- define_builtin (string[0], number[0], bp, SYMBOL_PUSHDEF);
- break;
+ quotearg_style_mem (locale_quoting_style, string[1],
+ number[1]));
+ bp = find_builtin_by_name (string[1]);
+ define_builtin (string[0], number[0], bp, SYMBOL_PUSHDEF);
+ break;
- case 'T':
+ case 'T':
- /* Enter a macro having an expansion text as a definition. */
+ /* Enter a macro having an expansion text as a definition. */
- define_user_macro (string[0], number[0], string[1], number[1],
- SYMBOL_PUSHDEF);
- break;
+ define_user_macro (string[0], number[0], string[1], number[1],
+ SYMBOL_PUSHDEF);
+ break;
- case 'Q':
+ case 'Q':
- /* Change quote strings. */
+ /* Change quote strings. */
- set_quotes (string[0], number[0], string[1], number[1]);
- break;
+ set_quotes (string[0], number[0], string[1], number[1]);
+ break;
- default:
+ default:
- /* Cannot happen. */
+ /* Cannot happen. */
- break;
- }
- break;
+ break;
+ }
+ break;
- }
+ }
GET_DIRECTIVE;
}
diff --git a/src/input.c b/src/input.c
index b5153eb..cf4a068 100644
--- a/src/input.c
+++ b/src/input.c
@@ -96,25 +96,25 @@ struct input_block
union
{
struct
- {
- char *str; /* Remaining string value. */
- size_t len; /* Remaining length. */
- }
- u_s; /* INPUT_STRING */
+ {
+ char *str; /* Remaining string value. */
+ size_t len; /* Remaining length. */
+ }
+ u_s; /* INPUT_STRING */
struct
- {
- FILE *fp; /* Input file handle. */
- bool_bitfield end : 1; /* True if peek has seen EOF. */
- bool_bitfield close : 1; /* True to close file on pop. */
- bool_bitfield advance : 1; /* Track previous start_of_input_line. */
- }
- u_f; /* INPUT_FILE */
+ {
+ FILE *fp; /* Input file handle. */
+ bool_bitfield end : 1; /* True if peek has seen EOF. */
+ bool_bitfield close : 1; /* True to close file on pop. */
+ bool_bitfield advance : 1; /* Track previous start_of_input_line. */
+ }
+ u_f; /* INPUT_FILE */
struct
- {
- token_chain *chain; /* Current link in chain. */
- token_chain *end; /* Last link in chain. */
- }
- u_c; /* INPUT_CHAIN */
+ {
+ token_chain *chain; /* Current link in chain. */
+ token_chain *end; /* Last link in chain. */
+ }
+ u_c; /* INPUT_CHAIN */
}
u;
};
@@ -222,9 +222,9 @@ make_text_link (struct obstack *obs, token_chain **start,
token_chain **end)
char *str = (char *) obstack_finish (obs);
chain = (token_chain *) obstack_alloc (obs, sizeof *chain);
if (*end)
- (*end)->next = chain;
+ (*end)->next = chain;
else
- *start = chain;
+ *start = chain;
*end = chain;
chain->next = NULL;
chain->type = CHAIN_STR;
@@ -257,7 +257,7 @@ push_file (FILE *fp, const char *title, bool
close_when_done)
if (debug_level & DEBUG_TRACE_INPUT)
debug_message ("input read from %s",
- quotearg_style (locale_quoting_style, title));
+ quotearg_style (locale_quoting_style, title));
i = (input_block *) obstack_alloc (current_input, sizeof *i);
i->type = INPUT_FILE;
@@ -283,7 +283,7 @@ push_file (FILE *fp, const char *title, bool
close_when_done)
`------------------------------------------------------------------*/
void
append_macro (struct obstack *obs, builtin_func *func, token_chain **start,
- token_chain **end)
+ token_chain **end)
{
token_chain *chain;
@@ -383,44 +383,44 @@ push_token (token_data *token, int level, bool inuse)
{
assert (level >= 0);
if (TOKEN_DATA_LEN (token) <= INPUT_INLINE_THRESHOLD)
- {
- obstack_grow (current_input, TOKEN_DATA_TEXT (token),
- TOKEN_DATA_LEN (token));
- return false;
- }
+ {
+ obstack_grow (current_input, TOKEN_DATA_TEXT (token),
+ TOKEN_DATA_LEN (token));
+ return false;
+ }
}
else if (TOKEN_DATA_TYPE (token) == TOKEN_FUNC)
{
if (next->type == INPUT_STRING)
- {
- next->type = INPUT_CHAIN;
- next->u.u_c.chain = next->u.u_c.end = NULL;
- }
+ {
+ next->type = INPUT_CHAIN;
+ next->u.u_c.chain = next->u.u_c.end = NULL;
+ }
append_macro (current_input, TOKEN_DATA_FUNC (token), &next->u.u_c.chain,
- &next->u.u_c.end);
+ &next->u.u_c.end);
return false;
}
else
{
/* For composite tokens, if argv is already in use, creating
- additional references for long text segments is more
- efficient in time. But if argv is not yet in use, and we
- have a composite token, then the token must already contain a
- back-reference, and memory usage is more efficient if we can
- avoid using the current expand_macro, even if it means larger
- copies. */
+ additional references for long text segments is more
+ efficient in time. But if argv is not yet in use, and we
+ have a composite token, then the token must already contain a
+ back-reference, and memory usage is more efficient if we can
+ avoid using the current expand_macro, even if it means larger
+ copies. */
assert (TOKEN_DATA_TYPE (token) == TOKEN_COMP);
src_chain = token->u.u_c.chain;
while (level >= 0 && src_chain && src_chain->type == CHAIN_STR
- && (src_chain->u.u_s.len <= INPUT_INLINE_THRESHOLD
- || (!inuse && src_chain->u.u_s.level == -1)))
- {
- obstack_grow (current_input, src_chain->u.u_s.str,
- src_chain->u.u_s.len);
- src_chain = src_chain->next;
- }
+ && (src_chain->u.u_s.len <= INPUT_INLINE_THRESHOLD
+ || (!inuse && src_chain->u.u_s.level == -1)))
+ {
+ obstack_grow (current_input, src_chain->u.u_s.str,
+ src_chain->u.u_s.len);
+ src_chain = src_chain->next;
+ }
if (!src_chain)
- return false;
+ return false;
}
if (next->type == INPUT_STRING)
@@ -433,9 +433,9 @@ push_token (token_data *token, int level, bool inuse)
{
chain = (token_chain *) obstack_alloc (current_input, sizeof *chain);
if (next->u.u_c.end)
- next->u.u_c.end->next = chain;
+ next->u.u_c.end->next = chain;
else
- next->u.u_c.chain = chain;
+ next->u.u_c.chain = chain;
next->u.u_c.end = chain;
chain->next = NULL;
chain->type = CHAIN_STR;
@@ -449,60 +449,60 @@ push_token (token_data *token, int level, bool inuse)
while (src_chain)
{
if (src_chain->type == CHAIN_FUNC)
- {
- append_macro (current_input, src_chain->u.func, &next->u.u_c.chain,
- &next->u.u_c.end);
- src_chain = src_chain->next;
- continue;
- }
+ {
+ append_macro (current_input, src_chain->u.func, &next->u.u_c.chain,
+ &next->u.u_c.end);
+ src_chain = src_chain->next;
+ continue;
+ }
if (level == -1)
- {
- /* Nothing to copy, since link already lives on obstack. */
- assert (src_chain->type != CHAIN_STR
- || src_chain->u.u_s.level == -1);
- chain = src_chain;
- }
+ {
+ /* Nothing to copy, since link already lives on obstack. */
+ assert (src_chain->type != CHAIN_STR
+ || src_chain->u.u_s.level == -1);
+ chain = src_chain;
+ }
else
- {
- /* Allow inlining the final link with subsequent text. */
- if (!src_chain->next && src_chain->type == CHAIN_STR
- && (src_chain->u.u_s.len <= INPUT_INLINE_THRESHOLD
- || (!inuse && src_chain->u.u_s.level == -1)))
- {
- obstack_grow (current_input, src_chain->u.u_s.str,
- src_chain->u.u_s.len);
- break;
- }
- /* We must clone each link in the chain, since next_char
- destructively modifies the chain it is parsing. */
- chain = (token_chain *) obstack_copy (current_input, src_chain,
- sizeof *chain);
- chain->next = NULL;
- if (chain->type == CHAIN_STR && chain->u.u_s.level == -1)
- {
- if (chain->u.u_s.len <= INPUT_INLINE_THRESHOLD || !inuse)
- chain->u.u_s.str = (char *) obstack_copy (current_input,
- chain->u.u_s.str,
- chain->u.u_s.len);
- else
- {
- chain->u.u_s.level = level;
- inuse = true;
- }
- }
- }
+ {
+ /* Allow inlining the final link with subsequent text. */
+ if (!src_chain->next && src_chain->type == CHAIN_STR
+ && (src_chain->u.u_s.len <= INPUT_INLINE_THRESHOLD
+ || (!inuse && src_chain->u.u_s.level == -1)))
+ {
+ obstack_grow (current_input, src_chain->u.u_s.str,
+ src_chain->u.u_s.len);
+ break;
+ }
+ /* We must clone each link in the chain, since next_char
+ destructively modifies the chain it is parsing. */
+ chain = (token_chain *) obstack_copy (current_input, src_chain,
+ sizeof *chain);
+ chain->next = NULL;
+ if (chain->type == CHAIN_STR && chain->u.u_s.level == -1)
+ {
+ if (chain->u.u_s.len <= INPUT_INLINE_THRESHOLD || !inuse)
+ chain->u.u_s.str = (char *) obstack_copy (current_input,
+ chain->u.u_s.str,
+ chain->u.u_s.len);
+ else
+ {
+ chain->u.u_s.level = level;
+ inuse = true;
+ }
+ }
+ }
if (next->u.u_c.end)
- next->u.u_c.end->next = chain;
+ next->u.u_c.end->next = chain;
else
- next->u.u_c.chain = chain;
+ next->u.u_c.chain = chain;
next->u.u_c.end = chain;
if (chain->type == CHAIN_ARGV)
- {
- assert (!chain->u.u_a.comma && !chain->u.u_a.skip_last);
- inuse |= arg_adjust_refcount (chain->u.u_a.argv, true);
- }
+ {
+ assert (!chain->u.u_a.comma && !chain->u.u_a.skip_last);
+ inuse |= arg_adjust_refcount (chain->u.u_a.argv, true);
+ }
else if (chain->type == CHAIN_STR && chain->u.u_s.level >= 0)
- adjust_refcount (chain->u.u_s.level, true);
+ adjust_refcount (chain->u.u_s.level, true);
src_chain = src_chain->next;
}
return inuse;
@@ -528,12 +528,12 @@ push_string_finish (void)
if (len || next->type == INPUT_CHAIN)
{
if (next->type == INPUT_STRING)
- {
- next->u.u_s.str = (char *) obstack_finish (current_input);
- next->u.u_s.len = len;
- }
+ {
+ next->u.u_s.str = (char *) obstack_finish (current_input);
+ next->u.u_s.len = len;
+ }
else
- make_text_link (current_input, &next->u.u_c.chain, &next->u.u_c.end);
+ make_text_link (current_input, &next->u.u_c.chain, &next->u.u_c.end);
next->prev = isp;
isp = next;
input_change = true;
@@ -560,7 +560,7 @@ push_wrapup_init (const call_info *caller, token_chain
***end)
{
i = wsp;
assert (i->type == INPUT_CHAIN && i->u.u_c.end
- && i->u.u_c.end->type != CHAIN_LOC);
+ && i->u.u_c.end->type != CHAIN_LOC);
}
else
{
@@ -618,61 +618,61 @@ pop_input (bool cleanup)
case INPUT_STRING:
assert (!cleanup || !isp->u.u_s.len);
if (isp->u.u_s.len)
- return false;
+ return false;
break;
case INPUT_CHAIN:
chain = isp->u.u_c.chain;
assert (!chain || !cleanup);
while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- if (chain->u.u_s.len)
- return false;
- if (chain->u.u_s.level >= 0)
- adjust_refcount (chain->u.u_s.level, false);
- break;
- case CHAIN_FUNC:
- if (chain->u.func)
- return false;
- break;
- case CHAIN_ARGV:
- if (chain->u.u_a.index < arg_argc (chain->u.u_a.argv))
- return false;
- arg_adjust_refcount (chain->u.u_a.argv, false);
- break;
- case CHAIN_LOC:
- return false;
- default:
- assert (!"pop_input");
- abort ();
- }
- isp->u.u_c.chain = chain = chain->next;
- }
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (chain->u.u_s.len)
+ return false;
+ if (chain->u.u_s.level >= 0)
+ adjust_refcount (chain->u.u_s.level, false);
+ break;
+ case CHAIN_FUNC:
+ if (chain->u.func)
+ return false;
+ break;
+ case CHAIN_ARGV:
+ if (chain->u.u_a.index < arg_argc (chain->u.u_a.argv))
+ return false;
+ arg_adjust_refcount (chain->u.u_a.argv, false);
+ break;
+ case CHAIN_LOC:
+ return false;
+ default:
+ assert (!"pop_input");
+ abort ();
+ }
+ isp->u.u_c.chain = chain = chain->next;
+ }
break;
case INPUT_FILE:
if (!cleanup)
- return false;
+ return false;
if (debug_level & DEBUG_TRACE_INPUT)
- {
- if (tmp != &input_eof)
- debug_message ("input reverted to %s, line %d",
- tmp->file, tmp->line);
- else
- debug_message ("input exhausted");
- }
+ {
+ if (tmp != &input_eof)
+ debug_message ("input reverted to %s, line %d",
+ tmp->file, tmp->line);
+ else
+ debug_message ("input exhausted");
+ }
if (ferror (isp->u.u_f.fp))
- {
- m4_error (0, 0, NULL, _("read error"));
- if (isp->u.u_f.close)
- fclose (isp->u.u_f.fp);
- }
+ {
+ m4_error (0, 0, NULL, _("read error"));
+ if (isp->u.u_f.close)
+ fclose (isp->u.u_f.fp);
+ }
else if (isp->u.u_f.close && fclose (isp->u.u_f.fp) == EOF)
- m4_error (0, errno, NULL, _("error reading file"));
+ m4_error (0, errno, NULL, _("error reading file"));
start_of_input_line = isp->u.u_f.advance;
output_current_line = -1;
break;
@@ -709,7 +709,7 @@ pop_wrapup (void)
if (wsp == &input_eof)
{
/* End of the program. Free all memory even though we are about
- to exit, since it makes leak detection easier. */
+ to exit, since it makes leak detection easier. */
obstack_free (&token_stack, NULL);
obstack_free (&file_names, NULL);
obstack_free (wrapup_stack, NULL);
@@ -761,32 +761,32 @@ input_print (struct obstack *obs)
case INPUT_CHAIN:
chain = next->u.u_c.chain;
while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- if (shipout_string_trunc (obs, chain->u.u_s.str,
- chain->u.u_s.len, &maxlen))
- return;
- break;
- case CHAIN_FUNC:
- func_print (obs, find_builtin_by_addr (chain->u.func), false,
- NULL, NULL);
- break;
- case CHAIN_ARGV:
- assert (!chain->u.u_a.comma);
- if (arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes),
- chain->u.u_a.flatten, NULL, NULL, &maxlen, false))
- return;
- break;
- default:
- assert (!"input_print");
- abort ();
- }
- chain = chain->next;
- }
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (shipout_string_trunc (obs, chain->u.u_s.str,
+ chain->u.u_s.len, &maxlen))
+ return;
+ break;
+ case CHAIN_FUNC:
+ func_print (obs, find_builtin_by_addr (chain->u.func), false,
+ NULL, NULL);
+ break;
+ case CHAIN_ARGV:
+ assert (!chain->u.u_a.comma);
+ if (arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes),
+ chain->u.u_a.flatten, NULL, NULL, &maxlen, false))
+ return;
+ break;
+ default:
+ assert (!"input_print");
+ abort ();
+ }
+ chain = chain->next;
+ }
break;
default:
assert (!"input_print");
@@ -794,7 +794,7 @@ input_print (struct obstack *obs)
}
if (len)
shipout_string_trunc (obs, (char *) obstack_base (current_input), len,
- &maxlen);
+ &maxlen);
}
@@ -821,81 +821,81 @@ next_buffer (size_t *len, bool allow_quote)
{
assert (isp);
if (input_change)
- {
- current_file = isp->file;
- current_line = isp->line;
- input_change = false;
- }
+ {
+ current_file = isp->file;
+ current_line = isp->line;
+ input_change = false;
+ }
switch (isp->type)
- {
- case INPUT_STRING:
- if (isp->u.u_s.len)
- {
- *len = isp->u.u_s.len;
- return isp->u.u_s.str;
- }
- break;
-
- case INPUT_FILE:
- if (start_of_input_line)
- {
- start_of_input_line = false;
- current_line = ++isp->line;
- }
- if (isp->u.u_f.end)
- break;
- return freadptr (isp->u.u_f.fp, len);
-
- case INPUT_CHAIN:
- chain = isp->u.u_c.chain;
- while (chain)
- {
- if (allow_quote && chain->quote_age == current_quote_age)
- return NULL; /* CHAR_QUOTE doesn't fit in buffer. */
- switch (chain->type)
- {
- case CHAIN_STR:
- if (chain->u.u_s.len)
- {
- *len = chain->u.u_s.len;
- return chain->u.u_s.str;
- }
- if (chain->u.u_s.level >= 0)
- adjust_refcount (chain->u.u_s.level, false);
- break;
- case CHAIN_FUNC:
- if (chain->u.func)
- return NULL; /* CHAR_MACRO doesn't fit in buffer. */
- break;
- case CHAIN_ARGV:
- if (chain->u.u_a.index == arg_argc (chain->u.u_a.argv))
- {
- arg_adjust_refcount (chain->u.u_a.argv, false);
- break;
- }
- return NULL; /* No buffer to provide. */
- case CHAIN_LOC:
- isp->file = chain->u.u_l.file;
- isp->line = chain->u.u_l.line;
- input_change = true;
- isp->u.u_c.chain = chain->next;
- return next_buffer (len, allow_quote);
- default:
- assert (!"next_buffer");
- abort ();
- }
- isp->u.u_c.chain = chain = chain->next;
- }
- break;
-
- case INPUT_EOF:
- return NULL; /* CHAR_EOF doesn't fit in buffer. */
-
- default:
- assert (!"next_buffer");
- abort ();
- }
+ {
+ case INPUT_STRING:
+ if (isp->u.u_s.len)
+ {
+ *len = isp->u.u_s.len;
+ return isp->u.u_s.str;
+ }
+ break;
+
+ case INPUT_FILE:
+ if (start_of_input_line)
+ {
+ start_of_input_line = false;
+ current_line = ++isp->line;
+ }
+ if (isp->u.u_f.end)
+ break;
+ return freadptr (isp->u.u_f.fp, len);
+
+ case INPUT_CHAIN:
+ chain = isp->u.u_c.chain;
+ while (chain)
+ {
+ if (allow_quote && chain->quote_age == current_quote_age)
+ return NULL; /* CHAR_QUOTE doesn't fit in buffer. */
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (chain->u.u_s.len)
+ {
+ *len = chain->u.u_s.len;
+ return chain->u.u_s.str;
+ }
+ if (chain->u.u_s.level >= 0)
+ adjust_refcount (chain->u.u_s.level, false);
+ break;
+ case CHAIN_FUNC:
+ if (chain->u.func)
+ return NULL; /* CHAR_MACRO doesn't fit in buffer. */
+ break;
+ case CHAIN_ARGV:
+ if (chain->u.u_a.index == arg_argc (chain->u.u_a.argv))
+ {
+ arg_adjust_refcount (chain->u.u_a.argv, false);
+ break;
+ }
+ return NULL; /* No buffer to provide. */
+ case CHAIN_LOC:
+ isp->file = chain->u.u_l.file;
+ isp->line = chain->u.u_l.line;
+ input_change = true;
+ isp->u.u_c.chain = chain->next;
+ return next_buffer (len, allow_quote);
+ default:
+ assert (!"next_buffer");
+ abort ();
+ }
+ isp->u.u_c.chain = chain = chain->next;
+ }
+ break;
+
+ case INPUT_EOF:
+ return NULL; /* CHAR_EOF doesn't fit in buffer. */
+
+ default:
+ assert (!"next_buffer");
+ abort ();
+ }
/* End of input source --- pop one level. */
pop_input (true);
@@ -931,15 +931,15 @@ consume_buffer (size_t len)
assert (buf && len <= buf_len);
buf_len = 0;
while ((p = (char *) memchr (buf + buf_len, '\n', len - buf_len)))
- {
- if (p == buf + len - 1)
- start_of_input_line = true;
- else
- current_line = ++isp->line;
- buf_len = p - buf + 1;
- }
+ {
+ if (p == buf + len - 1)
+ start_of_input_line = true;
+ else
+ current_line = ++isp->line;
+ buf_len = p - buf + 1;
+ }
if (freadseek (isp->u.u_f.fp, len) != 0)
- assert (false);
+ assert (false);
break;
case INPUT_CHAIN:
@@ -978,78 +978,78 @@ peek_input (bool allow_argv)
{
assert (block);
switch (block->type)
- {
- case INPUT_STRING:
- if (!block->u.u_s.len)
- break;
- return to_uchar (block->u.u_s.str[0]);
-
- case INPUT_FILE:
- ch = getc (block->u.u_f.fp);
- if (ch != EOF)
- {
- ungetc (ch, block->u.u_f.fp);
- return ch;
- }
- block->u.u_f.end = true;
- break;
-
- case INPUT_CHAIN:
- chain = block->u.u_c.chain;
- while (chain)
- {
- unsigned int argc;
- switch (chain->type)
- {
- case CHAIN_STR:
- if (chain->u.u_s.len)
- return to_uchar (*chain->u.u_s.str);
- break;
- case CHAIN_FUNC:
- if (chain->u.func)
- return CHAR_MACRO;
- break;
- case CHAIN_ARGV:
- argc = arg_argc (chain->u.u_a.argv);
- if (chain->u.u_a.index == argc)
- break;
- if (chain->u.u_a.comma)
- return ',';
- /* Only return a reference if the quoting is correct
- and the reference has more than one argument
- left. */
- if (allow_argv && chain->quote_age == current_quote_age
- && chain->u.u_a.quotes && chain->u.u_a.index + 1 < argc)
- return CHAR_ARGV;
- /* Rather than directly parse argv here, we push
- another input block containing the next unparsed
- argument from argv. */
- push_string_init (block->file, block->line);
- push_arg_quote (current_input, chain->u.u_a.argv,
- chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes));
- chain->u.u_a.index++;
- chain->u.u_a.comma = true;
- push_string_finish ();
- return peek_input (allow_argv);
- case CHAIN_LOC:
- break;
- default:
- assert (!"peek_input");
- abort ();
- }
- chain = chain->next;
- }
- break;
-
- case INPUT_EOF:
- return CHAR_EOF;
-
- default:
- assert (!"peek_input");
- abort ();
- }
+ {
+ case INPUT_STRING:
+ if (!block->u.u_s.len)
+ break;
+ return to_uchar (block->u.u_s.str[0]);
+
+ case INPUT_FILE:
+ ch = getc (block->u.u_f.fp);
+ if (ch != EOF)
+ {
+ ungetc (ch, block->u.u_f.fp);
+ return ch;
+ }
+ block->u.u_f.end = true;
+ break;
+
+ case INPUT_CHAIN:
+ chain = block->u.u_c.chain;
+ while (chain)
+ {
+ unsigned int argc;
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (chain->u.u_s.len)
+ return to_uchar (*chain->u.u_s.str);
+ break;
+ case CHAIN_FUNC:
+ if (chain->u.func)
+ return CHAR_MACRO;
+ break;
+ case CHAIN_ARGV:
+ argc = arg_argc (chain->u.u_a.argv);
+ if (chain->u.u_a.index == argc)
+ break;
+ if (chain->u.u_a.comma)
+ return ',';
+ /* Only return a reference if the quoting is correct
+ and the reference has more than one argument
+ left. */
+ if (allow_argv && chain->quote_age == current_quote_age
+ && chain->u.u_a.quotes && chain->u.u_a.index + 1 < argc)
+ return CHAR_ARGV;
+ /* Rather than directly parse argv here, we push
+ another input block containing the next unparsed
+ argument from argv. */
+ push_string_init (block->file, block->line);
+ push_arg_quote (current_input, chain->u.u_a.argv,
+ chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes));
+ chain->u.u_a.index++;
+ chain->u.u_a.comma = true;
+ push_string_finish ();
+ return peek_input (allow_argv);
+ case CHAIN_LOC:
+ break;
+ default:
+ assert (!"peek_input");
+ abort ();
+ }
+ chain = chain->next;
+ }
+ break;
+
+ case INPUT_EOF:
+ return CHAR_EOF;
+
+ default:
+ assert (!"peek_input");
+ abort ();
+ }
block = block->prev;
}
}
@@ -1084,114 +1084,114 @@ next_char_1 (bool allow_quote, bool allow_argv)
{
assert (isp);
if (input_change)
- {
- current_file = isp->file;
- current_line = isp->line;
- input_change = false;
- }
+ {
+ current_file = isp->file;
+ current_line = isp->line;
+ input_change = false;
+ }
switch (isp->type)
- {
- case INPUT_STRING:
- if (!isp->u.u_s.len)
- break;
- isp->u.u_s.len--;
- return to_uchar (*isp->u.u_s.str++);
-
- case INPUT_FILE:
- if (start_of_input_line)
- {
- start_of_input_line = false;
- current_line = ++isp->line;
- }
-
- /* If stdin is a terminal, calling getc after peek_input
- already called it would make the user have to hit ^D
- twice to quit. */
- ch = isp->u.u_f.end ? EOF : getc (isp->u.u_f.fp);
- if (ch != EOF)
- {
- if (ch == '\n')
- start_of_input_line = true;
- return ch;
- }
- break;
-
- case INPUT_CHAIN:
- chain = isp->u.u_c.chain;
- while (chain)
- {
- unsigned int argc;
- if (allow_quote && chain->quote_age == current_quote_age)
- return CHAR_QUOTE;
- switch (chain->type)
- {
- case CHAIN_STR:
- if (chain->u.u_s.len)
- {
- /* Partial consumption invalidates quote age. */
- chain->quote_age = 0;
- chain->u.u_s.len--;
- return to_uchar (*chain->u.u_s.str++);
- }
- if (chain->u.u_s.level >= 0)
- adjust_refcount (chain->u.u_s.level, false);
- break;
- case CHAIN_FUNC:
- if (chain->u.func)
- return CHAR_MACRO;
- break;
- case CHAIN_ARGV:
- argc = arg_argc (chain->u.u_a.argv);
- if (chain->u.u_a.index == argc)
- {
- arg_adjust_refcount (chain->u.u_a.argv, false);
- break;
- }
- if (chain->u.u_a.comma)
- {
- chain->u.u_a.comma = false;
- return ',';
- }
- /* Only return a reference if the quoting is correct
- and the reference has more than one argument
- left. */
- if (allow_argv && chain->quote_age == current_quote_age
- && chain->u.u_a.quotes && chain->u.u_a.index + 1 < argc)
- return CHAR_ARGV;
- /* Rather than directly parse argv here, we push
- another input block containing the next unparsed
- argument from argv. */
- push_string_init (isp->file, isp->line);
- push_arg_quote (current_input, chain->u.u_a.argv,
- chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes));
- chain->u.u_a.index++;
- chain->u.u_a.comma = true;
- push_string_finish ();
- return next_char_1 (allow_quote, allow_argv);
- case CHAIN_LOC:
- isp->file = chain->u.u_l.file;
- isp->line = chain->u.u_l.line;
- input_change = true;
- isp->u.u_c.chain = chain->next;
- return next_char_1 (allow_quote, allow_argv);
- default:
- assert (!"next_char_1");
- abort ();
- }
- isp->u.u_c.chain = chain = chain->next;
- }
- break;
-
- case INPUT_EOF:
- return CHAR_EOF;
-
- default:
- assert (!"next_char_1");
- abort ();
- }
+ {
+ case INPUT_STRING:
+ if (!isp->u.u_s.len)
+ break;
+ isp->u.u_s.len--;
+ return to_uchar (*isp->u.u_s.str++);
+
+ case INPUT_FILE:
+ if (start_of_input_line)
+ {
+ start_of_input_line = false;
+ current_line = ++isp->line;
+ }
+
+ /* If stdin is a terminal, calling getc after peek_input
+ already called it would make the user have to hit ^D
+ twice to quit. */
+ ch = isp->u.u_f.end ? EOF : getc (isp->u.u_f.fp);
+ if (ch != EOF)
+ {
+ if (ch == '\n')
+ start_of_input_line = true;
+ return ch;
+ }
+ break;
+
+ case INPUT_CHAIN:
+ chain = isp->u.u_c.chain;
+ while (chain)
+ {
+ unsigned int argc;
+ if (allow_quote && chain->quote_age == current_quote_age)
+ return CHAR_QUOTE;
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (chain->u.u_s.len)
+ {
+ /* Partial consumption invalidates quote age. */
+ chain->quote_age = 0;
+ chain->u.u_s.len--;
+ return to_uchar (*chain->u.u_s.str++);
+ }
+ if (chain->u.u_s.level >= 0)
+ adjust_refcount (chain->u.u_s.level, false);
+ break;
+ case CHAIN_FUNC:
+ if (chain->u.func)
+ return CHAR_MACRO;
+ break;
+ case CHAIN_ARGV:
+ argc = arg_argc (chain->u.u_a.argv);
+ if (chain->u.u_a.index == argc)
+ {
+ arg_adjust_refcount (chain->u.u_a.argv, false);
+ break;
+ }
+ if (chain->u.u_a.comma)
+ {
+ chain->u.u_a.comma = false;
+ return ',';
+ }
+ /* Only return a reference if the quoting is correct
+ and the reference has more than one argument
+ left. */
+ if (allow_argv && chain->quote_age == current_quote_age
+ && chain->u.u_a.quotes && chain->u.u_a.index + 1 < argc)
+ return CHAR_ARGV;
+ /* Rather than directly parse argv here, we push
+ another input block containing the next unparsed
+ argument from argv. */
+ push_string_init (isp->file, isp->line);
+ push_arg_quote (current_input, chain->u.u_a.argv,
+ chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes));
+ chain->u.u_a.index++;
+ chain->u.u_a.comma = true;
+ push_string_finish ();
+ return next_char_1 (allow_quote, allow_argv);
+ case CHAIN_LOC:
+ isp->file = chain->u.u_l.file;
+ isp->line = chain->u.u_l.line;
+ input_change = true;
+ isp->u.u_c.chain = chain->next;
+ return next_char_1 (allow_quote, allow_argv);
+ default:
+ assert (!"next_char_1");
+ abort ();
+ }
+ isp->u.u_c.chain = chain = chain->next;
+ }
+ break;
+
+ case INPUT_EOF:
+ return CHAR_EOF;
+
+ default:
+ assert (!"next_char_1");
+ abort ();
+ }
/* End of input source --- pop one level. */
pop_input (true);
@@ -1214,22 +1214,22 @@ skip_line (const call_info *name)
size_t len;
const char *buffer = next_buffer (&len, false);
if (buffer)
- {
- const char *p = (char *) memchr (buffer, '\n', len);
- if (p)
- {
- consume_buffer (p - buffer + 1);
- ch = '\n';
- break;
- }
- consume_buffer (len);
- }
+ {
+ const char *p = (char *) memchr (buffer, '\n', len);
+ if (p)
+ {
+ consume_buffer (p - buffer + 1);
+ ch = '\n';
+ break;
+ }
+ consume_buffer (len);
+ }
else
- {
- ch = next_char (false, false);
- if (ch == CHAR_EOF || ch == '\n')
- break;
- }
+ {
+ ch = next_char (false, false);
+ if (ch == CHAR_EOF || ch == '\n')
+ break;
+ }
}
if (ch == CHAR_EOF)
m4_warn (0, name, _("end of file treated as newline"));
@@ -1256,12 +1256,12 @@ init_macro_token (struct obstack *obs, token_data *td)
{
assert (td);
if (TOKEN_DATA_TYPE (td) == TOKEN_VOID)
- {
- TOKEN_DATA_TYPE (td) = TOKEN_COMP;
- td->u.u_c.chain = td->u.u_c.end = NULL;
- td->u.u_c.wrapper = false;
- td->u.u_c.has_func = true;
- }
+ {
+ TOKEN_DATA_TYPE (td) = TOKEN_COMP;
+ td->u.u_c.chain = td->u.u_c.end = NULL;
+ td->u.u_c.wrapper = false;
+ td->u.u_c.has_func = true;
+ }
assert (TOKEN_DATA_TYPE (td) == TOKEN_COMP);
append_macro (obs, chain->u.func, &td->u.u_c.chain, &td->u.u_c.end);
}
@@ -1334,8 +1334,8 @@ init_argv_token (struct obstack *obs, token_data *td)
int ch;
assert (TOKEN_DATA_TYPE (td) == TOKEN_VOID
- && isp->type == INPUT_CHAIN && isp->u.u_c.chain->type == CHAIN_ARGV
- && obs && obstack_object_size (obs) == 0);
+ && isp->type == INPUT_CHAIN && isp->u.u_c.chain->type == CHAIN_ARGV
+ && obs && obstack_object_size (obs) == 0);
src_chain = isp->u.u_c.chain;
isp->u.u_c.chain = src_chain->next;
@@ -1368,7 +1368,7 @@ init_argv_token (struct obstack *obs, token_data *td)
refcount here, to compensate for the fact that it will be
decreased once the final element is parsed. */
assert (!curr_comm.len1 || (*curr_comm.str1 != ',' && *curr_comm.str1 != ')'
- && *curr_comm.str1 != *curr_quote.str1));
+ && *curr_comm.str1 != *curr_quote.str1));
ch = peek_input (true);
if (ch != ',' && ch != ')')
{
@@ -1410,7 +1410,7 @@ match_input (const char *s, size_t slen, bool consume)
if (t && slen <= len && memcmp (s, t, slen) == 0)
{
if (consume)
- consume_buffer (slen);
+ consume_buffer (slen);
return true;
}
@@ -1422,7 +1422,7 @@ match_input (const char *s, size_t slen, bool consume)
if (slen == 1)
{
if (consume)
- next_char (false, false);
+ next_char (false, false);
return true; /* short match */
}
@@ -1432,12 +1432,12 @@ match_input (const char *s, size_t slen, bool consume)
next_char (false, false);
n++;
if (--slen == 1) /* long match */
- {
- if (consume)
- return true;
- result = true;
- break;
- }
+ {
+ if (consume)
+ return true;
+ result = true;
+ break;
+ }
}
/* Failed or shouldn't consume, push back input. */
@@ -1618,7 +1618,7 @@ set_word_regexp (const call_info *caller, const char
*regexp, size_t len)
len = strlen (regexp);
if (len == 0
|| (len == strlen (DEFAULT_WORD_REGEXP)
- && !memcmp (regexp, DEFAULT_WORD_REGEXP, len)))
+ && !memcmp (regexp, DEFAULT_WORD_REGEXP, len)))
{
default_word_regexp = true;
set_quote_age ();
@@ -1633,7 +1633,7 @@ set_word_regexp (const call_info *caller, const char
*regexp, size_t len)
if (msg != NULL)
{
m4_warn (0, caller, _("bad regular expression %s: %s"),
- quotearg_style_mem (locale_quoting_style, regexp, len), msg);
+ quotearg_style_mem (locale_quoting_style, regexp, len), msg);
return;
}
@@ -1706,11 +1706,11 @@ set_quote_age (void)
&& (!*curr_quote.str2 || strchr (unsafe, *curr_quote.str2) == NULL)
&& default_word_regexp && *curr_quote.str1 != *curr_quote.str2
&& (!curr_comm.len1
- || (*curr_comm.str1 != '(' && *curr_comm.str1 != ','
- && *curr_comm.str1 != ')'
- && *curr_comm.str1 != *curr_quote.str1)))
+ || (*curr_comm.str1 != '(' && *curr_comm.str1 != ','
+ && *curr_comm.str1 != ')'
+ && *curr_comm.str1 != *curr_quote.str1)))
current_quote_age = (((*curr_quote.str1 & 0xff) << 8)
- | (*curr_quote.str2 & 0xff));
+ | (*curr_quote.str2 & 0xff));
else
current_quote_age = 0;
cached_quote = NULL;
@@ -1778,11 +1778,11 @@ quote_cache (struct obstack *obs, unsigned int age,
const string_pair *quotes)
{
assert (obs == current_input && obstack_object_size (obs) == 0);
cached_quote = (string_pair *) obstack_copy (obs, quotes,
- sizeof *quotes);
+ sizeof *quotes);
cached_quote->str1 = (char *) obstack_copy0 (obs, quotes->str1,
- quotes->len1);
+ quotes->len1);
cached_quote->str2 = (char *) obstack_copy0 (obs, quotes->str2,
- quotes->len2);
+ quotes->len2);
}
return cached_quote;
}
@@ -1813,7 +1813,7 @@ quote_cache (struct obstack *obs, unsigned int age, const
string_pair *quotes)
token_type
next_token (token_data *td, int *line, struct obstack *obs, bool allow_argv,
- const call_info *caller)
+ const call_info *caller)
{
int ch;
int quote_level;
@@ -1848,7 +1848,7 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
init_macro_token (obs, td);
#ifdef DEBUG_INPUT
xfprintf (stderr, "next_token -> MACDEF (%s)\n",
- find_builtin_by_addr (TOKEN_DATA_FUNC (td))->name);
+ find_builtin_by_addr (TOKEN_DATA_FUNC (td))->name);
#endif /* DEBUG_INPUT */
return TOKEN_MACDEF;
}
@@ -1857,9 +1857,9 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
init_argv_token (obs, td);
#ifdef DEBUG_INPUT
xfprintf (stderr, "next_token -> ARGV (%d args)\n",
- (arg_argc (td->u.u_c.chain->u.u_a.argv)
- - td->u.u_c.chain->u.u_a.index
- - (td->u.u_c.chain->u.u_a.skip_last ? 1 : 0)));
+ (arg_argc (td->u.u_c.chain->u.u_a.argv)
+ - td->u.u_c.chain->u.u_a.index
+ - (td->u.u_c.chain->u.u_a.skip_last ? 1 : 0)));
#endif
return TOKEN_ARGV;
}
@@ -1868,37 +1868,37 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
{
obstack_1grow (&token_stack, ch);
while (1)
- {
- size_t len;
- const char *buffer = next_buffer (&len, false);
- if (buffer)
- {
- const char *p = buffer;
- while (len && (isalnum (to_uchar (*p)) || *p == '_'))
- {
- p++;
- len--;
- }
- if (p != buffer)
- {
- obstack_grow (&token_stack, buffer, p - buffer);
- consume_buffer (p - buffer);
- }
- if (len)
- break;
- }
- else
- {
- ch = peek_input (false);
- if (ch < CHAR_EOF && (isalnum (ch) || ch == '_'))
- {
- obstack_1grow (&token_stack, ch);
- next_char (false, false);
- }
- else
- break;
- }
- }
+ {
+ size_t len;
+ const char *buffer = next_buffer (&len, false);
+ if (buffer)
+ {
+ const char *p = buffer;
+ while (len && (isalnum (to_uchar (*p)) || *p == '_'))
+ {
+ p++;
+ len--;
+ }
+ if (p != buffer)
+ {
+ obstack_grow (&token_stack, buffer, p - buffer);
+ consume_buffer (p - buffer);
+ }
+ if (len)
+ break;
+ }
+ else
+ {
+ ch = peek_input (false);
+ if (ch < CHAR_EOF && (isalnum (ch) || ch == '_'))
+ {
+ obstack_1grow (&token_stack, ch);
+ next_char (false, false);
+ }
+ else
+ break;
+ }
+ }
type = TOKEN_WORD;
}
@@ -1908,20 +1908,20 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
{
obstack_1grow (&token_stack, ch);
while (1)
- {
- ch = peek_input (false);
- if (ch >= CHAR_EOF)
- break;
- obstack_1grow (&token_stack, ch);
- if (re_match (&word_regexp, (char *) obstack_base (&token_stack),
- obstack_object_size (&token_stack), 0, ®s)
- != (regoff_t) obstack_object_size (&token_stack))
- {
- obstack_blank (&token_stack, -1);
- break;
- }
- next_char (false, false);
- }
+ {
+ ch = peek_input (false);
+ if (ch >= CHAR_EOF)
+ break;
+ obstack_1grow (&token_stack, ch);
+ if (re_match (&word_regexp, (char *) obstack_base (&token_stack),
+ obstack_object_size (&token_stack), 0, ®s)
+ != (regoff_t) obstack_object_size (&token_stack))
+ {
+ obstack_blank (&token_stack, -1);
+ break;
+ }
+ next_char (false, false);
+ }
TOKEN_DATA_ORIG_LEN (td) = obstack_object_size (&token_stack);
obstack_1grow (&token_stack, '\0');
@@ -1929,10 +1929,10 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
TOKEN_DATA_ORIG_TEXT (td) = orig_text;
if (regs.start[1] != -1)
- obstack_grow (&token_stack, orig_text + regs.start[1],
- regs.end[1] - regs.start[1]);
+ obstack_grow (&token_stack, orig_text + regs.start[1],
+ regs.end[1] - regs.start[1]);
else
- obstack_grow (&token_stack, orig_text, regs.end[0]);
+ obstack_grow (&token_stack, orig_text, regs.end[0]);
type = TOKEN_WORD;
}
@@ -1942,158 +1942,158 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
else if (MATCH (ch, curr_quote.str1, curr_quote.len1, true))
{
if (obs)
- obs_td = obs;
+ obs_td = obs;
quote_level = 1;
type = TOKEN_STRING;
while (1)
- {
- /* Start with buffer search for either potential delimiter. */
- size_t len;
- const char *buffer = next_buffer (&len, obs && current_quote_age);
- if (buffer)
- {
- const char *p = buffer;
- do
- {
- p = (char *) memchr2 (p, *curr_quote.str1, *curr_quote.str2,
- buffer + len - p);
- }
- while (p && current_quote_age
- && (*p++ == *curr_quote.str2
- ? --quote_level : ++quote_level));
- if (p)
- {
- if (current_quote_age)
- {
- assert (!quote_level);
- obstack_grow (obs_td, buffer, p - buffer - 1);
- consume_buffer (p - buffer);
- break;
- }
- obstack_grow (obs_td, buffer, p - buffer);
- ch = to_uchar (*p);
- consume_buffer (p - buffer + 1);
- }
- else
- {
- obstack_grow (obs_td, buffer, len);
- consume_buffer (len);
- continue;
- }
- }
-
- /* Fall back to byte-wise search. */
- else
- ch = next_char (obs && current_quote_age, false);
- if (ch == CHAR_EOF)
- {
- /* Current_file changed to "" if we see CHAR_EOF, use
- the previous value we stored earlier. */
- if (!caller)
- {
- assert (line);
- current_line = *line;
- current_file = file;
- }
- m4_error (EXIT_FAILURE, 0, caller, _("end of file in string"));
- }
- if (ch == CHAR_MACRO)
- init_macro_token (obs, obs ? td : NULL);
- else if (ch == CHAR_QUOTE)
- append_quote_token (obs, td);
- else if (MATCH (ch, curr_quote.str2, curr_quote.len2, true))
- {
- if (--quote_level == 0)
- break;
- obstack_grow (obs_td, curr_quote.str2, curr_quote.len2);
- }
- else if (MATCH (ch, curr_quote.str1, curr_quote.len1, true))
- {
- quote_level++;
- obstack_grow (obs_td, curr_quote.str1, curr_quote.len1);
- }
- else
- {
- assert (ch < CHAR_EOF);
- obstack_1grow (obs_td, ch);
- }
- }
+ {
+ /* Start with buffer search for either potential delimiter. */
+ size_t len;
+ const char *buffer = next_buffer (&len, obs && current_quote_age);
+ if (buffer)
+ {
+ const char *p = buffer;
+ do
+ {
+ p = (char *) memchr2 (p, *curr_quote.str1, *curr_quote.str2,
+ buffer + len - p);
+ }
+ while (p && current_quote_age
+ && (*p++ == *curr_quote.str2
+ ? --quote_level : ++quote_level));
+ if (p)
+ {
+ if (current_quote_age)
+ {
+ assert (!quote_level);
+ obstack_grow (obs_td, buffer, p - buffer - 1);
+ consume_buffer (p - buffer);
+ break;
+ }
+ obstack_grow (obs_td, buffer, p - buffer);
+ ch = to_uchar (*p);
+ consume_buffer (p - buffer + 1);
+ }
+ else
+ {
+ obstack_grow (obs_td, buffer, len);
+ consume_buffer (len);
+ continue;
+ }
+ }
+
+ /* Fall back to byte-wise search. */
+ else
+ ch = next_char (obs && current_quote_age, false);
+ if (ch == CHAR_EOF)
+ {
+ /* Current_file changed to "" if we see CHAR_EOF, use
+ the previous value we stored earlier. */
+ if (!caller)
+ {
+ assert (line);
+ current_line = *line;
+ current_file = file;
+ }
+ m4_error (EXIT_FAILURE, 0, caller, _("end of file in string"));
+ }
+ if (ch == CHAR_MACRO)
+ init_macro_token (obs, obs ? td : NULL);
+ else if (ch == CHAR_QUOTE)
+ append_quote_token (obs, td);
+ else if (MATCH (ch, curr_quote.str2, curr_quote.len2, true))
+ {
+ if (--quote_level == 0)
+ break;
+ obstack_grow (obs_td, curr_quote.str2, curr_quote.len2);
+ }
+ else if (MATCH (ch, curr_quote.str1, curr_quote.len1, true))
+ {
+ quote_level++;
+ obstack_grow (obs_td, curr_quote.str1, curr_quote.len1);
+ }
+ else
+ {
+ assert (ch < CHAR_EOF);
+ obstack_1grow (obs_td, ch);
+ }
+ }
}
else if (MATCH (ch, curr_comm.str1, curr_comm.len1, true))
{
if (obs)
- obs_td = obs;
+ obs_td = obs;
obstack_grow (obs_td, curr_comm.str1, curr_comm.len1);
while (1)
- {
- /* Start with buffer search for potential end delimiter. */
- size_t len;
- const char *buffer = next_buffer (&len, false);
- if (buffer)
- {
- const char *p = (char *) memchr (buffer, *curr_comm.str2, len);
- if (p)
- {
- obstack_grow (obs_td, buffer, p - buffer);
- ch = to_uchar (*p);
- consume_buffer (p - buffer + 1);
- }
- else
- {
- obstack_grow (obs_td, buffer, len);
- consume_buffer (len);
- continue;
- }
- }
-
- /* Fall back to byte-wise search. */
- else
- ch = next_char (false, false);
- if (ch == CHAR_EOF)
- {
- /* Current_file changed to "" if we see CHAR_EOF, use
- the previous value we stored earlier. */
- if (!caller)
- {
- assert (line);
- current_line = *line;
- current_file = file;
- }
- m4_error (EXIT_FAILURE, 0, caller, _("end of file in comment"));
- }
- if (ch == CHAR_MACRO)
- {
- init_macro_token (obs, obs ? td : NULL);
- continue;
- }
- if (MATCH (ch, curr_comm.str2, curr_comm.len2, true))
- {
- obstack_grow (obs_td, curr_comm.str2, curr_comm.len2);
- break;
- }
- assert (ch < CHAR_EOF);
- obstack_1grow (obs_td, ch);
- }
+ {
+ /* Start with buffer search for potential end delimiter. */
+ size_t len;
+ const char *buffer = next_buffer (&len, false);
+ if (buffer)
+ {
+ const char *p = (char *) memchr (buffer, *curr_comm.str2, len);
+ if (p)
+ {
+ obstack_grow (obs_td, buffer, p - buffer);
+ ch = to_uchar (*p);
+ consume_buffer (p - buffer + 1);
+ }
+ else
+ {
+ obstack_grow (obs_td, buffer, len);
+ consume_buffer (len);
+ continue;
+ }
+ }
+
+ /* Fall back to byte-wise search. */
+ else
+ ch = next_char (false, false);
+ if (ch == CHAR_EOF)
+ {
+ /* Current_file changed to "" if we see CHAR_EOF, use
+ the previous value we stored earlier. */
+ if (!caller)
+ {
+ assert (line);
+ current_line = *line;
+ current_file = file;
+ }
+ m4_error (EXIT_FAILURE, 0, caller, _("end of file in comment"));
+ }
+ if (ch == CHAR_MACRO)
+ {
+ init_macro_token (obs, obs ? td : NULL);
+ continue;
+ }
+ if (MATCH (ch, curr_comm.str2, curr_comm.len2, true))
+ {
+ obstack_grow (obs_td, curr_comm.str2, curr_comm.len2);
+ break;
+ }
+ assert (ch < CHAR_EOF);
+ obstack_1grow (obs_td, ch);
+ }
type = TOKEN_COMMENT;
}
else
{
assert (ch < CHAR_EOF);
switch (ch)
- {
- case '(':
- type = TOKEN_OPEN;
- break;
- case ',':
- type = TOKEN_COMMA;
- break;
- case ')':
- type = TOKEN_CLOSE;
- break;
- default:
- type = TOKEN_SIMPLE;
- break;
- }
+ {
+ case '(':
+ type = TOKEN_OPEN;
+ break;
+ case ',':
+ type = TOKEN_COMMA;
+ break;
+ case ')':
+ type = TOKEN_CLOSE;
+ break;
+ default:
+ type = TOKEN_SIMPLE;
+ break;
+ }
obstack_1grow (&token_stack, ch);
}
@@ -2102,61 +2102,61 @@ next_token (token_data *td, int *line, struct obstack
*obs, bool allow_argv,
TOKEN_DATA_TYPE (td) = TOKEN_TEXT;
TOKEN_DATA_LEN (td) = obstack_object_size (obs_td);
if (obs_td != obs)
- {
- obstack_1grow (obs_td, '\0');
- TOKEN_DATA_TEXT (td) = (char *) obstack_finish (obs_td);
- }
+ {
+ obstack_1grow (obs_td, '\0');
+ TOKEN_DATA_TEXT (td) = (char *) obstack_finish (obs_td);
+ }
else
- TOKEN_DATA_TEXT (td) = NULL;
+ TOKEN_DATA_TEXT (td) = NULL;
TOKEN_DATA_QUOTE_AGE (td) = current_quote_age;
#ifdef ENABLE_CHANGEWORD
if (!orig_text)
- {
- TOKEN_DATA_ORIG_TEXT (td) = TOKEN_DATA_TEXT (td);
- TOKEN_DATA_ORIG_LEN (td) = TOKEN_DATA_LEN (td);
- }
+ {
+ TOKEN_DATA_ORIG_TEXT (td) = TOKEN_DATA_TEXT (td);
+ TOKEN_DATA_ORIG_LEN (td) = TOKEN_DATA_LEN (td);
+ }
#endif /* ENABLE_CHANGEWORD */
#ifdef DEBUG_INPUT
xfprintf (stderr, "next_token -> %s (%s), len %zu\n",
- token_type_string (type), TOKEN_DATA_TEXT (td),
- TOKEN_DATA_LEN (td));
+ token_type_string (type), TOKEN_DATA_TEXT (td),
+ TOKEN_DATA_LEN (td));
#endif /* DEBUG_INPUT */
}
else
{
assert (TOKEN_DATA_TYPE (td) == TOKEN_COMP
- && (type == TOKEN_STRING || type == TOKEN_COMMENT));
+ && (type == TOKEN_STRING || type == TOKEN_COMMENT));
#ifdef DEBUG_INPUT
{
- token_chain *chain;
- size_t len = 0;
- int links = 0;
- chain = td->u.u_c.chain;
- xfprintf (stderr, "next_token -> %s <chain> (",
- token_type_string (type));
- while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- xfprintf (stderr, "%s", chain->u.u_s.str);
- len += chain->u.u_s.len;
- break;
- case CHAIN_FUNC:
- xfprintf (stderr, "<func>");
- break;
- case CHAIN_ARGV:
- xfprintf (stderr, "address@hidden");
- break;
- default:
- assert (!"next_token");
- abort ();
- }
- links++;
- chain = chain->next;
- }
- xfprintf (stderr, "), %d links, len %zu\n",
- links, len);
+ token_chain *chain;
+ size_t len = 0;
+ int links = 0;
+ chain = td->u.u_c.chain;
+ xfprintf (stderr, "next_token -> %s <chain> (",
+ token_type_string (type));
+ while (chain)
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ xfprintf (stderr, "%s", chain->u.u_s.str);
+ len += chain->u.u_s.len;
+ break;
+ case CHAIN_FUNC:
+ xfprintf (stderr, "<func>");
+ break;
+ case CHAIN_ARGV:
+ xfprintf (stderr, "address@hidden");
+ break;
+ default:
+ assert (!"next_token");
+ abort ();
+ }
+ links++;
+ chain = chain->next;
+ }
+ xfprintf (stderr, "), %d links, len %zu\n",
+ links, len);
}
#endif /* DEBUG_INPUT */
}
@@ -2201,16 +2201,16 @@ peek_token (void)
switch (ch)
{
case '(':
- result = TOKEN_OPEN;
- break;
+ result = TOKEN_OPEN;
+ break;
case ',':
- result = TOKEN_COMMA;
- break;
+ result = TOKEN_COMMA;
+ break;
case ')':
- result = TOKEN_CLOSE;
- break;
+ result = TOKEN_CLOSE;
+ break;
default:
- result = TOKEN_SIMPLE;
+ result = TOKEN_SIMPLE;
}
#ifdef DEBUG_INPUT
diff --git a/src/m4.c b/src/m4.c
index f9ac386..ccc350b 100644
--- a/src/m4.c
+++ b/src/m4.c
@@ -87,7 +87,7 @@ typedef struct macro_definition macro_definition;
static void M4_GNUC_PRINTF (5, 0)
m4_verror_at_line (bool warn, int status, int errnum, const call_info *caller,
- const char *format, va_list args)
+ const char *format, va_list args)
{
char *full = NULL;
char *safe_macro = NULL;
@@ -104,14 +104,14 @@ m4_verror_at_line (bool warn, int status, int errnum,
const call_info *caller,
char *p = safe_macro = xcharalloc (2 * len);
const char *end = macro + len;
while (macro != end)
- {
- if (*macro == '%')
- {
- *p++ = '%';
- len++;
- }
- *p++ = *macro++;
- }
+ {
+ if (*macro == '%')
+ {
+ *p++ = '%';
+ len++;
+ }
+ *p++ = *macro++;
+ }
}
if (macro)
/* Use slot 1, so that the rest of the code can use the simpler
@@ -127,7 +127,7 @@ m4_verror_at_line (bool warn, int status, int errnum, const
call_info *caller,
else if (macro)
full = xasprintf (_("%s: %s"), macro, format);
verror_at_line (status, errnum, line ? file : NULL, line,
- full ? full : format, args);
+ full ? full : format, args);
free (full);
free (safe_macro);
if ((!warn || fatal_warnings) && !retcode)
@@ -143,7 +143,7 @@ m4_verror_at_line (bool warn, int status, int errnum, const
call_info *caller,
void
m4_error (int status, int errnum, const call_info *caller,
- const char *format, ...)
+ const char *format, ...)
{
va_list args;
va_start (args, format);
@@ -182,7 +182,7 @@ static void
stackovf_handler (void)
{
m4_error (EXIT_FAILURE, 0, NULL,
- _("FATAL: stack overflow. (Infinite define recursion?)"));
+ _("FATAL: stack overflow. (Infinite define recursion?)"));
}
#endif /* USE_STACKOVF */
@@ -197,7 +197,7 @@ usage (int status)
{
if (status != EXIT_SUCCESS)
xfprintf (stderr, _("Try `%s --help' for more information.\n"),
- program_name);
+ program_name);
else
{
xprintf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name);
@@ -351,11 +351,11 @@ process_file (const char *name)
if (STREQ (name, "-"))
{
/* If stdin is a terminal, we want to allow 'm4 - file -'
- to read input from stdin twice, like GNU cat. Besides,
- there is no point closing stdin before wrapped text, to
- minimize bugs in syscmd called from wrapped text. */
+ to read input from stdin twice, like GNU cat. Besides,
+ there is no point closing stdin before wrapped text, to
+ minimize bugs in syscmd called from wrapped text. */
/* TRANSLATORS: This is a short name for `standard input', used
- when a command line file was given as `-'. */
+ when a command line file was given as `-'. */
push_file (stdin, _("stdin"), false);
}
else
@@ -363,14 +363,14 @@ process_file (const char *name)
char *full_name;
FILE *fp = m4_path_search (name, &full_name);
if (fp == NULL)
- {
- error (0, errno, _("cannot open %s"),
- quotearg_style (locale_quoting_style, name));
- /* Set the status to EXIT_FAILURE, even though we
- continue to process files after a missing file. */
- retcode = EXIT_FAILURE;
- return;
- }
+ {
+ error (0, errno, _("cannot open %s"),
+ quotearg_style (locale_quoting_style, name));
+ /* Set the status to EXIT_FAILURE, even though we
+ continue to process files after a missing file. */
+ retcode = EXIT_FAILURE;
+ return;
+ }
push_file (fp, full_name, true);
free (full_name);
}
@@ -437,152 +437,152 @@ main (int argc, char *const *argv, char *const *envp
M4_GNUC_UNUSED)
head = tail = NULL;
while ((optchar = getopt_long (argc, (char **) argv, OPTSTRING,
- long_options, NULL)) != -1)
+ long_options, NULL)) != -1)
switch (optchar)
{
default:
- usage (EXIT_FAILURE);
+ usage (EXIT_FAILURE);
case 'B':
case 'S':
case 'T':
- /* Compatibility junk: options that other implementations
- support, but which we ignore as no-ops and don't list in
- --help. */
- error (0, 0, _("warning: `m4 -%c' may be removed in a future release"),
- optchar);
- break;
+ /* Compatibility junk: options that other implementations
+ support, but which we ignore as no-ops and don't list in
+ --help. */
+ error (0, 0, _("warning: `m4 -%c' may be removed in a future release"),
+ optchar);
+ break;
case '\1':
- seen_file = true;
- /* fall through */
+ seen_file = true;
+ /* fall through */
case 'D':
case 'U':
case 's':
case 't':
case DEBUGFILE_OPTION:
defer:
- /* Arguments that cannot be handled until later are accumulated. */
+ /* Arguments that cannot be handled until later are accumulated. */
- defn = (macro_definition *) xmalloc (sizeof (macro_definition));
- defn->code = optchar;
- defn->arg = optarg;
- defn->next = NULL;
+ defn = (macro_definition *) xmalloc (sizeof (macro_definition));
+ defn->code = optchar;
+ defn->arg = optarg;
+ defn->next = NULL;
- if (head == NULL)
- head = defn;
- else
- tail->next = defn;
- tail = defn;
+ if (head == NULL)
+ head = defn;
+ else
+ tail->next = defn;
+ tail = defn;
- break;
+ break;
case 'E':
- debug_decode ("-d", SIZE_MAX);
- if (!fatal_warnings)
- fatal_warnings = true;
- else
- warning_status = EXIT_FAILURE;
- break;
+ debug_decode ("-d", SIZE_MAX);
+ if (!fatal_warnings)
+ fatal_warnings = true;
+ else
+ warning_status = EXIT_FAILURE;
+ break;
case 'F':
- frozen_file_to_write = optarg;
- break;
+ frozen_file_to_write = optarg;
+ break;
case 'G':
- no_gnu_extensions = 1;
- break;
+ no_gnu_extensions = 1;
+ break;
case 'H':
{
- long tmp = strtol (optarg, NULL, 10);
+ long tmp = strtol (optarg, NULL, 10);
hash_table_size = tmp;
}
- if (hash_table_size == 0)
- hash_table_size = HASHMAX;
- break;
+ if (hash_table_size == 0)
+ hash_table_size = HASHMAX;
+ break;
case 'I':
- add_include_directory (optarg);
- break;
+ add_include_directory (optarg);
+ break;
case 'L':
{
long tmp = strtol (optarg, NULL, 10);
nesting_limit = tmp;
}
- break;
+ break;
case 'P':
- prefix_all_builtins = 1;
- break;
+ prefix_all_builtins = 1;
+ break;
case 'Q':
- suppress_warnings = 1;
- break;
+ suppress_warnings = 1;
+ break;
case 'R':
- frozen_file_to_read = optarg;
- break;
+ frozen_file_to_read = optarg;
+ break;
#ifdef ENABLE_CHANGEWORD
case 'W':
- user_word_regexp = optarg;
- break;
+ user_word_regexp = optarg;
+ break;
#endif
case 'd':
- if (seen_file)
- goto defer;
- if (debug_decode (optarg, SIZE_MAX) < 0)
- error (0, 0, _("bad debug flags: %s"),
- quotearg_style (locale_quoting_style, optarg));
- break;
+ if (seen_file)
+ goto defer;
+ if (debug_decode (optarg, SIZE_MAX) < 0)
+ error (0, 0, _("bad debug flags: %s"),
+ quotearg_style (locale_quoting_style, optarg));
+ break;
case 'e':
- error (0, 0, _("warning: `%s' is deprecated, use `%s' instead"),
- "-e", "-i");
- /* fall through */
+ error (0, 0, _("warning: `%s' is deprecated, use `%s' instead"),
+ "-e", "-i");
+ /* fall through */
case 'i':
- interactive = true;
- break;
+ interactive = true;
+ break;
case 'g':
- no_gnu_extensions = 0;
- break;
+ no_gnu_extensions = 0;
+ break;
case 'l':
- {
- long tmp = strtol (optarg, NULL, 10);
- max_debug_argument_length = tmp <= 0 ? SIZE_MAX : (size_t) tmp;
- }
- break;
+ {
+ long tmp = strtol (optarg, NULL, 10);
+ max_debug_argument_length = tmp <= 0 ? SIZE_MAX : (size_t) tmp;
+ }
+ break;
case 'o':
- /* -o/--error-output are deprecated synonyms of --debugfile,
- so issue a warning. Don't call debug_set_output here, as
- it has side effects. */
- error (0, 0, _("warning: `%s' is deprecated, use `%s' instead"),
- optchar == 'o' ? "-o" : "--error-output", "--debugfile");
- debugfile = optarg;
- break;
+ /* -o/--error-output are deprecated synonyms of --debugfile,
+ so issue a warning. Don't call debug_set_output here, as
+ it has side effects. */
+ error (0, 0, _("warning: `%s' is deprecated, use `%s' instead"),
+ optchar == 'o' ? "-o" : "--error-output", "--debugfile");
+ debugfile = optarg;
+ break;
case WARN_MACRO_SEQUENCE_OPTION:
- /* Don't call set_macro_sequence here, as it can exit.
- --warn-macro-sequence sets optarg to NULL (which uses the
- default regexp); --warn-macro-sequence= sets optarg to ""
- (which disables these warnings). */
- macro_sequence = optarg;
- break;
+ /* Don't call set_macro_sequence here, as it can exit.
+ --warn-macro-sequence sets optarg to NULL (which uses the
+ default regexp); --warn-macro-sequence= sets optarg to ""
+ (which disables these warnings). */
+ macro_sequence = optarg;
+ break;
case VERSION_OPTION:
- version_etc (stdout, PACKAGE, PACKAGE_NAME, VERSION, AUTHORS, NULL);
- exit (EXIT_SUCCESS);
- break;
+ version_etc (stdout, PACKAGE, PACKAGE_NAME, VERSION, AUTHORS, NULL);
+ exit (EXIT_SUCCESS);
+ break;
case HELP_OPTION:
- usage (EXIT_SUCCESS);
- break;
+ usage (EXIT_SUCCESS);
+ break;
}
defines = head;
@@ -590,7 +590,7 @@ main (int argc, char *const *argv, char *const *envp
M4_GNUC_UNUSED)
/* Do the basic initializations. */
if (debugfile && !debug_set_output (NULL, debugfile))
m4_error (0, errno, NULL, _("cannot set debug file %s"),
- quotearg_style (locale_quoting_style, debugfile));
+ quotearg_style (locale_quoting_style, debugfile));
input_init ();
output_init ();
@@ -621,50 +621,50 @@ main (int argc, char *const *argv, char *const *envp
M4_GNUC_UNUSED)
const char *arg = defines->arg;
switch (defines->code)
- {
- case 'D':
- {
- const char *value = strchr (arg, '=');
- size_t len = value ? (size_t) (value - arg) : strlen (arg);
- define_user_macro (arg, len, value ? value + 1 : "",
- value ? SIZE_MAX : 0, SYMBOL_INSERT);
- }
- break;
-
- case 'U':
- lookup_symbol (arg, strlen (arg), SYMBOL_DELETE);
- break;
-
- case 'd':
- if (debug_decode (arg, SIZE_MAX) < 0)
- error (0, 0, _("bad debug flags: %s"),
- quotearg_style (locale_quoting_style, optarg));
- break;
-
- case 't':
- sym = lookup_symbol (arg, strlen (arg), SYMBOL_INSERT);
- SYMBOL_TRACED (sym) = true;
- break;
-
- case 's':
- sync_output = 1;
- break;
-
- case '\1':
- process_file (arg);
- break;
-
- case DEBUGFILE_OPTION:
- if (!debug_set_output (NULL, arg))
- m4_error (0, errno, NULL, _("cannot set debug file %s"),
- quotearg_style (locale_quoting_style,
- arg ? arg : _("stderr")));
- break;
-
- default:
- assert (!"main");
- abort ();
- }
+ {
+ case 'D':
+ {
+ const char *value = strchr (arg, '=');
+ size_t len = value ? (size_t) (value - arg) : strlen (arg);
+ define_user_macro (arg, len, value ? value + 1 : "",
+ value ? SIZE_MAX : 0, SYMBOL_INSERT);
+ }
+ break;
+
+ case 'U':
+ lookup_symbol (arg, strlen (arg), SYMBOL_DELETE);
+ break;
+
+ case 'd':
+ if (debug_decode (arg, SIZE_MAX) < 0)
+ error (0, 0, _("bad debug flags: %s"),
+ quotearg_style (locale_quoting_style, optarg));
+ break;
+
+ case 't':
+ sym = lookup_symbol (arg, strlen (arg), SYMBOL_INSERT);
+ SYMBOL_TRACED (sym) = true;
+ break;
+
+ case 's':
+ sync_output = 1;
+ break;
+
+ case '\1':
+ process_file (arg);
+ break;
+
+ case DEBUGFILE_OPTION:
+ if (!debug_set_output (NULL, arg))
+ m4_error (0, errno, NULL, _("cannot set debug file %s"),
+ quotearg_style (locale_quoting_style,
+ arg ? arg : _("stderr")));
+ break;
+
+ default:
+ assert (!"main");
+ abort ();
+ }
next = defines->next;
free (defines);
diff --git a/src/m4.h b/src/m4.h
index b0e717d..d89e941 100644
--- a/src/m4.h
+++ b/src/m4.h
@@ -167,7 +167,7 @@ void m4_warn (int, const call_info *, const char *, ...)
M4_GNUC_PRINTF (3, 4);
#ifdef USE_STACKOVF
void setup_stackovf_trap (char *const *, char *const *,
- void (*handler) (void));
+ void (*handler) (void));
#endif
/* File: debug.c --- debugging and tracing function. */
@@ -266,29 +266,29 @@ struct token_chain
union
{
struct
- {
- const char *str; /* Pointer to text. */
- size_t len; /* Remaining length of str. */
- int level; /* Expansion level of link content, or -1. */
- }
+ {
+ const char *str; /* Pointer to text. */
+ size_t len; /* Remaining length of str. */
+ int level; /* Expansion level of link content, or -1. */
+ }
u_s;
builtin_func *func; /* Builtin token from defn. */
struct
- {
- macro_arguments *argv; /* Reference to earlier address@hidden
*/
- unsigned int index; /* Argument index within argv. */
- bool_bitfield flatten : 1; /* True to treat builtins as text. */
- bool_bitfield comma : 1; /* True when `,' is next input. */
- bool_bitfield skip_last : 1; /* True if last argument omitted. */
- bool_bitfield has_func : 1; /* True if argv includes func. */
- const string_pair *quotes; /* NULL for $*, quotes for
address@hidden */
- }
+ {
+ macro_arguments *argv; /* Reference to earlier address@hidden
*/
+ unsigned int index; /* Argument index within argv. */
+ bool_bitfield flatten : 1; /* True to treat builtins as text. */
+ bool_bitfield comma : 1; /* True when `,' is next input. */
+ bool_bitfield skip_last : 1; /* True if last argument omitted. */
+ bool_bitfield has_func : 1; /* True if argv includes func. */
+ const string_pair *quotes; /* NULL for $*, quotes for
address@hidden */
+ }
u_a;
struct
- {
- const char *file; /* File where subsequent links originate. */
- int line; /* Line where subsequent links originate. */
- }
+ {
+ const char *file; /* File where subsequent links originate. */
+ int line; /* Line where subsequent links originate. */
+ }
u_l;
}
u;
@@ -301,40 +301,40 @@ struct token_data
union
{
struct
- {
- /* We don't support NUL in text, yet. So len is just a
- cache for now. But it will be essential if we ever DO
- support NUL. */
- size_t len;
- char *text; /* The contents of the token. */
- /* The value of quote_age when this token was scanned. If
- this token is later encountered in the context of
- scanning a quoted string, and quote_age has not changed,
- then rescanning this string is provably unnecessary. If
- zero, then this string potentially contains content that
- might change the parse on rescan. Ignored for 0 len. */
- unsigned int quote_age;
+ {
+ /* We don't support NUL in text, yet. So len is just a
+ cache for now. But it will be essential if we ever DO
+ support NUL. */
+ size_t len;
+ char *text; /* The contents of the token. */
+ /* The value of quote_age when this token was scanned. If
+ this token is later encountered in the context of
+ scanning a quoted string, and quote_age has not changed,
+ then rescanning this string is provably unnecessary. If
+ zero, then this string potentially contains content that
+ might change the parse on rescan. Ignored for 0 len. */
+ unsigned int quote_age;
#ifdef ENABLE_CHANGEWORD
- /* If changeword is in effect, and contains a () group, then
- this contains the entire token, while text contains the
- portion that matched the () group to form a macro name.
- Otherwise, this field is unused. */
- const char *original_text;
- size_t original_len; /* Length of original_text. */
+ /* If changeword is in effect, and contains a () group, then
+ this contains the entire token, while text contains the
+ portion that matched the () group to form a macro name.
+ Otherwise, this field is unused. */
+ const char *original_text;
+ size_t original_len; /* Length of original_text. */
#endif
- }
+ }
u_t;
builtin_func *func;
/* Composite text: a linked list of straight text and $@
- placeholders. */
+ placeholders. */
struct
- {
- token_chain *chain; /* First link of the chain. */
- token_chain *end; /* Last link of the chain. */
- bool_bitfield wrapper : 1; /* True if this is a $@ ref. */
- bool_bitfield has_func : 1; /* True if chain includes func. */
- }
+ {
+ token_chain *chain; /* First link of the chain. */
+ token_chain *end; /* Last link of the chain. */
+ bool_bitfield wrapper : 1; /* True if this is a $@ ref. */
+ bool_bitfield has_func : 1; /* True if chain includes func. */
+ }
u_c;
}
u;
@@ -356,14 +356,14 @@ typedef enum token_data_type token_data_type;
void input_init (void);
token_type peek_token (void);
token_type next_token (token_data *, int *, struct obstack *, bool,
- const call_info *);
+ const call_info *);
void skip_line (const call_info *);
/* push back input */
void make_text_link (struct obstack *, token_chain **, token_chain **);
void push_file (FILE *, const char *, bool);
void append_macro (struct obstack *, builtin_func *, token_chain **,
- token_chain **);
+ token_chain **);
void push_macro (struct obstack *, builtin_func *);
struct obstack *push_string_init (const char *, int);
bool push_token (token_data *, int, bool);
@@ -394,7 +394,7 @@ void set_word_regexp (const call_info *, const char *,
size_t);
unsigned int quote_age (void);
bool safe_quotes (void);
const string_pair *quote_cache (struct obstack *, unsigned int,
- const string_pair *);
+ const string_pair *);
/* File: output.c --- output functions. */
extern int current_diversion;
@@ -480,13 +480,13 @@ size_t arg_len (macro_arguments *, unsigned int, bool);
builtin_func *arg_func (macro_arguments *, unsigned int);
struct obstack *arg_scratch (void);
bool arg_print (struct obstack *, macro_arguments *, unsigned int,
- const string_pair *, bool, token_chain **, const char *,
- size_t *, bool);
+ const string_pair *, bool, token_chain **, const char *,
+ size_t *, bool);
macro_arguments *make_argv_ref (macro_arguments *, const char *, size_t,
- bool, bool);
+ bool, bool);
void push_arg (struct obstack *, macro_arguments *, unsigned int);
void push_arg_quote (struct obstack *, macro_arguments *, unsigned int,
- const string_pair *);
+ const string_pair *);
void push_args (struct obstack *, macro_arguments *, bool, bool);
void wrap_args (macro_arguments *);
@@ -533,7 +533,7 @@ void define_builtin (const char *, size_t, const builtin *,
symbol_lookup);
void set_macro_sequence (const char *);
void free_regex (void);
void define_user_macro (const char *, size_t, const char *, size_t,
- symbol_lookup);
+ symbol_lookup);
void undivert_all (void);
void expand_user_macro (struct obstack *, symbol *, int, macro_arguments *);
void m4_placeholder (struct obstack *, int, macro_arguments *);
@@ -542,7 +542,7 @@ void init_pattern_buffer (struct re_pattern_buffer *,
struct re_registers *);
const builtin *find_builtin_by_addr (builtin_func *);
const builtin *find_builtin_by_name (const char *);
void func_print (struct obstack *, const builtin *, bool, token_chain **,
- const string_pair *);
+ const string_pair *);
/* File: path.c --- path search for include files. */
diff --git a/src/macro.c b/src/macro.c
index 47e0315..c6f768c 100644
--- a/src/macro.c
+++ b/src/macro.c
@@ -96,7 +96,7 @@ struct macro_arguments
thresholds of the input engine, the interesting sequence of events
is as follows:
- stacks[0] refs stacks[1] refs
+ stacks[0] refs stacks[1] refs
after second dnl ends: `' 0 `' 0
expand_macro for x, level 0: `' 1 `' 0
expand_macro for a, level 1: `' 1 `' 1
@@ -165,7 +165,7 @@ typedef struct macro_arg_stacks macro_arg_stacks;
static void expand_macro (symbol *);
static bool expand_token (struct obstack *, token_type, token_data *, int,
- bool);
+ bool);
/* Array of stacks, one element per macro recursion level. */
static macro_arg_stacks *stacks;
@@ -230,12 +230,12 @@ expand_input (void)
{
assert (stacks[i].refcount == 0 && stacks[i].argcount == 0);
if (stacks[i].args)
- {
- obstack_free (stacks[i].args, NULL);
- free (stacks[i].args);
- obstack_free (stacks[i].argv, NULL);
- free (stacks[i].argv);
- }
+ {
+ obstack_free (stacks[i].args, NULL);
+ free (stacks[i].args);
+ obstack_free (stacks[i].argv, NULL);
+ free (stacks[i].argv);
+ }
}
free (stacks);
stacks = NULL;
@@ -258,7 +258,7 @@ expand_input (void)
static bool
expand_token (struct obstack *obs, token_type t, token_data *td, int line,
- bool first)
+ bool first)
{
symbol *sym;
bool result = false;
@@ -272,68 +272,68 @@ expand_token (struct obstack *obs, token_type t,
token_data *td, int line,
case TOKEN_STRING:
/* Strings are safe in isolation (since quote_age() detects any
- change in delimiters), or when safe_quotes is true. When
- safe_quotes is false, we could technically return true if we
- can prove that the concatenation of this string to prior text
- does not form a multi-byte quote delimiter, but that is a lot
- of overhead, so we give the conservative answer of false. */
+ change in delimiters), or when safe_quotes is true. When
+ safe_quotes is false, we could technically return true if we
+ can prove that the concatenation of this string to prior text
+ does not form a multi-byte quote delimiter, but that is a lot
+ of overhead, so we give the conservative answer of false. */
result = first || safe_quotes ();
/* fallthru */
case TOKEN_COMMENT:
/* Comments can contain unbalanced quote delimiters. Rather
- than search for one, we return the conservative answer of
- false. If obstack is provided, the string or comment was
- already expanded into it during next_token. */
+ than search for one, we return the conservative answer of
+ false. If obstack is provided, the string or comment was
+ already expanded into it during next_token. */
if (obs)
- return result;
+ return result;
break;
case TOKEN_OPEN:
case TOKEN_COMMA:
case TOKEN_CLOSE:
/* If safe_quotes is true, then these do not form a quote
- delimiter. If it is false, we give the conservative answer
- of false rather than taking time to prove that no multi-byte
- quote delimiter is formed. */
+ delimiter. If it is false, we give the conservative answer
+ of false rather than taking time to prove that no multi-byte
+ quote delimiter is formed. */
result = safe_quotes ();
break;
case TOKEN_SIMPLE:
/* If safe_quotes is true, then all but the single-byte end
- quote delimiter is safe in a quoted context; a single-byte
- start delimiter will trigger a TOKEN_STRING instead. If
- safe_quotes is false, we give the conservative answer of
- false rather than taking time to prove that no multi-byte
- quote delimiter is formed. */
+ quote delimiter is safe in a quoted context; a single-byte
+ start delimiter will trigger a TOKEN_STRING instead. If
+ safe_quotes is false, we give the conservative answer of
+ false rather than taking time to prove that no multi-byte
+ quote delimiter is formed. */
result = *TOKEN_DATA_TEXT (td) != *curr_quote.str2 && safe_quotes ();
if (result)
- assert (*TOKEN_DATA_TEXT (td) != *curr_quote.str1);
+ assert (*TOKEN_DATA_TEXT (td) != *curr_quote.str1);
break;
case TOKEN_WORD:
sym = lookup_symbol (TOKEN_DATA_TEXT (td), TOKEN_DATA_LEN (td),
- SYMBOL_LOOKUP);
+ SYMBOL_LOOKUP);
if (sym == NULL || SYMBOL_TYPE (sym) == TOKEN_VOID
- || (SYMBOL_TYPE (sym) == TOKEN_FUNC
- && SYMBOL_BLIND_NO_ARGS (sym)
- && peek_token () != TOKEN_OPEN))
- {
+ || (SYMBOL_TYPE (sym) == TOKEN_FUNC
+ && SYMBOL_BLIND_NO_ARGS (sym)
+ && peek_token () != TOKEN_OPEN))
+ {
#ifdef ENABLE_CHANGEWORD
- divert_text (obs, TOKEN_DATA_ORIG_TEXT (td),
- TOKEN_DATA_ORIG_LEN (td), line);
+ divert_text (obs, TOKEN_DATA_ORIG_TEXT (td),
+ TOKEN_DATA_ORIG_LEN (td), line);
#else
- divert_text (obs, TOKEN_DATA_TEXT (td), TOKEN_DATA_LEN (td), line);
+ divert_text (obs, TOKEN_DATA_TEXT (td), TOKEN_DATA_LEN (td), line);
#endif /* !ENABLE_CHANGEWORD */
- /* If safe_quotes is true, then words do not overlap with
- quote delimiters. If it is false, we give the
- conservative answer of false rather than prove that no
- multi-byte delimiters are formed. */
- return safe_quotes();
- }
+ /* If safe_quotes is true, then words do not overlap with
+ quote delimiters. If it is false, we give the
+ conservative answer of false rather than prove that no
+ multi-byte delimiters are formed. */
+ return safe_quotes();
+ }
expand_macro (sym);
/* Expanding a macro creates new tokens to scan, and those new
- tokens may append unsafe text later; but we did not append
- any text now. */
+ tokens may append unsafe text later; but we did not append
+ any text now. */
return true;
default:
@@ -358,7 +358,7 @@ expand_token (struct obstack *obs, token_type t, token_data
*td, int line,
static bool
expand_argument (struct obstack *obs, token_data *argp,
- const call_info *caller)
+ const call_info *caller)
{
token_type t;
token_data td;
@@ -382,104 +382,104 @@ expand_argument (struct obstack *obs, token_data *argp,
{
switch (t)
- { /* TOKSW */
- case TOKEN_COMMA:
- case TOKEN_CLOSE:
- if (paren_level == 0)
- {
- assert (TOKEN_DATA_TYPE (argp) != TOKEN_FUNC);
- if (TOKEN_DATA_TYPE (argp) != TOKEN_COMP)
- {
- size_t len = obstack_object_size (obs);
- TOKEN_DATA_TYPE (argp) = TOKEN_TEXT;
- if (len)
- {
- obstack_1grow (obs, '\0');
- TOKEN_DATA_TEXT (argp) = (char *) obstack_finish (obs);
- }
- else
- TOKEN_DATA_TEXT (argp) = NULL;
- TOKEN_DATA_LEN (argp) = len;
- TOKEN_DATA_QUOTE_AGE (argp) = age;
- }
- else
- {
- make_text_link (obs, NULL, &argp->u.u_c.end);
- if (argp->u.u_c.chain == argp->u.u_c.end
- && argp->u.u_c.chain->type == CHAIN_FUNC)
- {
- builtin_func *func = argp->u.u_c.chain->u.func;
- TOKEN_DATA_TYPE (argp) = TOKEN_FUNC;
- TOKEN_DATA_FUNC (argp) = func;
- }
- }
- return t == TOKEN_COMMA;
- }
- /* fallthru */
- case TOKEN_OPEN:
- case TOKEN_SIMPLE:
- if (t == TOKEN_OPEN)
- paren_level++;
- else if (t == TOKEN_CLOSE)
- paren_level--;
- if (!expand_token (obs, t, &td, line, first))
- age = 0;
- break;
-
- case TOKEN_EOF:
- m4_error (EXIT_FAILURE, 0, caller,
- _("end of file in argument list"));
- break;
-
- case TOKEN_WORD:
- case TOKEN_STRING:
- case TOKEN_COMMENT:
- case TOKEN_MACDEF:
- if (!expand_token (obs, t, &td, line, first))
- age = 0;
- if (TOKEN_DATA_TYPE (&td) == TOKEN_COMP)
- {
- if (TOKEN_DATA_TYPE (argp) != TOKEN_COMP)
- {
- TOKEN_DATA_TYPE (argp) = TOKEN_COMP;
- argp->u.u_c.chain = td.u.u_c.chain;
- argp->u.u_c.wrapper = argp->u.u_c.has_func = false;
- }
- else
- {
- assert (argp->u.u_c.end);
- argp->u.u_c.end->next = td.u.u_c.chain;
- }
- argp->u.u_c.end = td.u.u_c.end;
- if (td.u.u_c.has_func)
- argp->u.u_c.has_func = true;
- }
- break;
-
- case TOKEN_ARGV:
- assert (paren_level == 0 && TOKEN_DATA_TYPE (argp) == TOKEN_VOID
- && obstack_object_size (obs) == 0
- && td.u.u_c.chain == td.u.u_c.end
- && td.u.u_c.chain->quote_age == age
- && td.u.u_c.chain->type == CHAIN_ARGV);
- TOKEN_DATA_TYPE (argp) = TOKEN_COMP;
- argp->u.u_c.chain = argp->u.u_c.end = td.u.u_c.chain;
- argp->u.u_c.wrapper = true;
- argp->u.u_c.has_func = td.u.u_c.has_func;
- t = next_token (&td, NULL, NULL, false, caller);
- if (argp->u.u_c.chain->u.u_a.skip_last)
- assert (t == TOKEN_COMMA);
- else
- assert (t == TOKEN_COMMA || t == TOKEN_CLOSE);
- return t == TOKEN_COMMA;
-
- default:
- assert (!"expand_argument");
- abort ();
- }
+ { /* TOKSW */
+ case TOKEN_COMMA:
+ case TOKEN_CLOSE:
+ if (paren_level == 0)
+ {
+ assert (TOKEN_DATA_TYPE (argp) != TOKEN_FUNC);
+ if (TOKEN_DATA_TYPE (argp) != TOKEN_COMP)
+ {
+ size_t len = obstack_object_size (obs);
+ TOKEN_DATA_TYPE (argp) = TOKEN_TEXT;
+ if (len)
+ {
+ obstack_1grow (obs, '\0');
+ TOKEN_DATA_TEXT (argp) = (char *) obstack_finish (obs);
+ }
+ else
+ TOKEN_DATA_TEXT (argp) = NULL;
+ TOKEN_DATA_LEN (argp) = len;
+ TOKEN_DATA_QUOTE_AGE (argp) = age;
+ }
+ else
+ {
+ make_text_link (obs, NULL, &argp->u.u_c.end);
+ if (argp->u.u_c.chain == argp->u.u_c.end
+ && argp->u.u_c.chain->type == CHAIN_FUNC)
+ {
+ builtin_func *func = argp->u.u_c.chain->u.func;
+ TOKEN_DATA_TYPE (argp) = TOKEN_FUNC;
+ TOKEN_DATA_FUNC (argp) = func;
+ }
+ }
+ return t == TOKEN_COMMA;
+ }
+ /* fallthru */
+ case TOKEN_OPEN:
+ case TOKEN_SIMPLE:
+ if (t == TOKEN_OPEN)
+ paren_level++;
+ else if (t == TOKEN_CLOSE)
+ paren_level--;
+ if (!expand_token (obs, t, &td, line, first))
+ age = 0;
+ break;
+
+ case TOKEN_EOF:
+ m4_error (EXIT_FAILURE, 0, caller,
+ _("end of file in argument list"));
+ break;
+
+ case TOKEN_WORD:
+ case TOKEN_STRING:
+ case TOKEN_COMMENT:
+ case TOKEN_MACDEF:
+ if (!expand_token (obs, t, &td, line, first))
+ age = 0;
+ if (TOKEN_DATA_TYPE (&td) == TOKEN_COMP)
+ {
+ if (TOKEN_DATA_TYPE (argp) != TOKEN_COMP)
+ {
+ TOKEN_DATA_TYPE (argp) = TOKEN_COMP;
+ argp->u.u_c.chain = td.u.u_c.chain;
+ argp->u.u_c.wrapper = argp->u.u_c.has_func = false;
+ }
+ else
+ {
+ assert (argp->u.u_c.end);
+ argp->u.u_c.end->next = td.u.u_c.chain;
+ }
+ argp->u.u_c.end = td.u.u_c.end;
+ if (td.u.u_c.has_func)
+ argp->u.u_c.has_func = true;
+ }
+ break;
+
+ case TOKEN_ARGV:
+ assert (paren_level == 0 && TOKEN_DATA_TYPE (argp) == TOKEN_VOID
+ && obstack_object_size (obs) == 0
+ && td.u.u_c.chain == td.u.u_c.end
+ && td.u.u_c.chain->quote_age == age
+ && td.u.u_c.chain->type == CHAIN_ARGV);
+ TOKEN_DATA_TYPE (argp) = TOKEN_COMP;
+ argp->u.u_c.chain = argp->u.u_c.end = td.u.u_c.chain;
+ argp->u.u_c.wrapper = true;
+ argp->u.u_c.has_func = td.u.u_c.has_func;
+ t = next_token (&td, NULL, NULL, false, caller);
+ if (argp->u.u_c.chain->u.u_a.skip_last)
+ assert (t == TOKEN_COMMA);
+ else
+ assert (t == TOKEN_COMMA || t == TOKEN_CLOSE);
+ return t == TOKEN_COMMA;
+
+ default:
+ assert (!"expand_argument");
+ abort ();
+ }
if (TOKEN_DATA_TYPE (argp) != TOKEN_VOID || obstack_object_size (obs))
- first = false;
+ first = false;
t = next_token (&td, NULL, obs, first, caller);
}
}
@@ -492,7 +492,7 @@ expand_argument (struct obstack *obs, token_data *argp,
static macro_arguments *
collect_arguments (symbol *sym, call_info *info, struct obstack *arguments,
- struct obstack *argv_stack)
+ struct obstack *argv_stack)
{
token_data td;
token_data *tdp;
@@ -518,52 +518,52 @@ collect_arguments (symbol *sym, call_info *info, struct
obstack *arguments,
/* gobble parenthesis */
next_token (&td, NULL, NULL, false, info);
do
- {
- tdp = (token_data *) obstack_alloc (arguments, sizeof *tdp);
- more_args = expand_argument (arguments, tdp, info);
-
- if ((TOKEN_DATA_TYPE (tdp) == TOKEN_TEXT && !TOKEN_DATA_LEN (tdp))
- || (!groks_macro_args && TOKEN_DATA_TYPE (tdp) == TOKEN_FUNC))
- {
- obstack_free (arguments, tdp);
- tdp = &empty_token;
- }
- obstack_ptr_grow (argv_stack, tdp);
- args.arraylen++;
- args.argc++;
- switch (TOKEN_DATA_TYPE (tdp))
- {
- case TOKEN_TEXT:
- /* Be conservative - any change in quoting while
- collecting arguments, or any argument that consists
- of unsafe text, will require a rescan if $@ is
- reused. */
- if (TOKEN_DATA_LEN (tdp) > 0
- && TOKEN_DATA_QUOTE_AGE (tdp) != args.quote_age)
- args.quote_age = 0;
- break;
- case TOKEN_FUNC:
- args.has_func = true;
- break;
- case TOKEN_COMP:
- args.has_ref = true;
- if (tdp->u.u_c.wrapper)
- {
- assert (tdp->u.u_c.chain->type == CHAIN_ARGV
- && !tdp->u.u_c.chain->next);
- args.argc += (tdp->u.u_c.chain->u.u_a.argv->argc
- - tdp->u.u_c.chain->u.u_a.index
- - tdp->u.u_c.chain->u.u_a.skip_last - 1);
- args.wrapper = true;
- }
- if (tdp->u.u_c.has_func)
- args.has_func = true;
- break;
- default:
- assert (!"expand_argument");
- abort ();
- }
- }
+ {
+ tdp = (token_data *) obstack_alloc (arguments, sizeof *tdp);
+ more_args = expand_argument (arguments, tdp, info);
+
+ if ((TOKEN_DATA_TYPE (tdp) == TOKEN_TEXT && !TOKEN_DATA_LEN (tdp))
+ || (!groks_macro_args && TOKEN_DATA_TYPE (tdp) == TOKEN_FUNC))
+ {
+ obstack_free (arguments, tdp);
+ tdp = &empty_token;
+ }
+ obstack_ptr_grow (argv_stack, tdp);
+ args.arraylen++;
+ args.argc++;
+ switch (TOKEN_DATA_TYPE (tdp))
+ {
+ case TOKEN_TEXT:
+ /* Be conservative - any change in quoting while
+ collecting arguments, or any argument that consists
+ of unsafe text, will require a rescan if $@ is
+ reused. */
+ if (TOKEN_DATA_LEN (tdp) > 0
+ && TOKEN_DATA_QUOTE_AGE (tdp) != args.quote_age)
+ args.quote_age = 0;
+ break;
+ case TOKEN_FUNC:
+ args.has_func = true;
+ break;
+ case TOKEN_COMP:
+ args.has_ref = true;
+ if (tdp->u.u_c.wrapper)
+ {
+ assert (tdp->u.u_c.chain->type == CHAIN_ARGV
+ && !tdp->u.u_c.chain->next);
+ args.argc += (tdp->u.u_c.chain->u.u_a.argv->argc
+ - tdp->u.u_c.chain->u.u_a.index
+ - tdp->u.u_c.chain->u.u_a.skip_last - 1);
+ args.wrapper = true;
+ }
+ if (tdp->u.u_c.has_func)
+ args.has_func = true;
+ break;
+ default:
+ assert (!"expand_argument");
+ abort ();
+ }
+ }
while (more_args);
}
argv = (macro_arguments *) obstack_finish (argv_stack);
@@ -637,24 +637,24 @@ expand_macro (symbol *sym)
{
size_t old_count = stacks_count;
stacks = (macro_arg_stacks *) x2nrealloc (stacks, &stacks_count,
- sizeof *stacks);
+ sizeof *stacks);
memset (&stacks[old_count], 0,
- sizeof *stacks * (stacks_count - old_count));
+ sizeof *stacks * (stacks_count - old_count));
}
if (!stacks[level].args)
{
assert (!stacks[level].refcount);
stacks[level].args =
- (struct obstack *) xmalloc (sizeof *stacks[level].args);
+ (struct obstack *) xmalloc (sizeof *stacks[level].args);
stacks[level].argv =
- (struct obstack *) xmalloc (sizeof *stacks[level].argv);
+ (struct obstack *) xmalloc (sizeof *stacks[level].argv);
obstack_init (stacks[level].args);
obstack_init (stacks[level].argv);
stacks[level].args_base = obstack_finish (stacks[level].args);
stacks[level].argv_base = obstack_finish (stacks[level].argv);
}
assert (obstack_object_size (stacks[level].args) == 0
- && obstack_object_size (stacks[level].argv) == 0);
+ && obstack_object_size (stacks[level].argv) == 0);
args_base = obstack_finish (stacks[level].args);
argv_base = obstack_finish (stacks[level].argv);
adjust_refcount (level, true);
@@ -665,8 +665,8 @@ expand_macro (symbol *sym)
expansion_level++;
if (nesting_limit > 0 && expansion_level > nesting_limit)
m4_error (EXIT_FAILURE, 0, NULL,
- _("recursion limit of %d exceeded, use -L<N> to change it"),
- nesting_limit);
+ _("recursion limit of %d exceeded, use -L<N> to change it"),
+ nesting_limit);
/* Collect context in effect at start of macro, even if global state
changes in the meantime. */
@@ -681,7 +681,7 @@ expand_macro (symbol *sym)
/* Collect the arguments. */
argv = collect_arguments (sym, &my_call_info, stacks[level].args,
- stacks[level].argv);
+ stacks[level].argv);
args_scratch = obstack_finish (stacks[level].args);
/* The actual macro call. */
@@ -706,20 +706,20 @@ expand_macro (symbol *sym)
if (stacks[level].refcount)
{
if (argv->inuse)
- {
- obstack_free (stacks[level].args, args_scratch);
- if (debug_macro_level & PRINT_ARGCOUNT_CHANGES)
- xfprintf (debug, "m4debug: -%d- `%s' in use, level=%d, "
- "refcount=%zu, argcount=%zu\n", my_call_info.call_id,
- my_call_info.name, level, stacks[level].refcount,
- stacks[level].argcount);
- }
+ {
+ obstack_free (stacks[level].args, args_scratch);
+ if (debug_macro_level & PRINT_ARGCOUNT_CHANGES)
+ xfprintf (debug, "m4debug: -%d- `%s' in use, level=%d, "
+ "refcount=%zu, argcount=%zu\n", my_call_info.call_id,
+ my_call_info.name, level, stacks[level].refcount,
+ stacks[level].argcount);
+ }
else
- {
- obstack_free (stacks[level].args, args_base);
- obstack_free (stacks[level].argv, argv_base);
- stacks[level].argcount--;
- }
+ {
+ obstack_free (stacks[level].args, args_base);
+ obstack_free (stacks[level].argv, argv_base);
+ stacks[level].argcount--;
+ }
}
}
@@ -739,15 +739,15 @@ adjust_refcount (int level, bool increase)
obstack_free (stacks[level].args, stacks[level].args_base);
obstack_free (stacks[level].argv, stacks[level].argv_base);
if ((debug_macro_level & PRINT_ARGCOUNT_CHANGES)
- && stacks[level].argcount > 1)
- xfprintf (debug, "m4debug: -%d- freeing %zu args, level=%d\n",
- macro_call_id, stacks[level].argcount, level);
+ && stacks[level].argcount > 1)
+ xfprintf (debug, "m4debug: -%d- freeing %zu args, level=%d\n",
+ macro_call_id, stacks[level].argcount, level);
stacks[level].argcount = 0;
}
if (debug_macro_level
& (increase ? PRINT_REFCOUNT_INCREASE : PRINT_REFCOUNT_DECREASE))
xfprintf (debug, "m4debug: level %d refcount=%zu\n", level,
- stacks[level].refcount);
+ stacks[level].refcount);
return stacks[level].refcount;
}
@@ -764,29 +764,29 @@ arg_adjust_refcount (macro_arguments *argv, bool increase)
if (argv->has_ref)
for (i = 0; i < argv->arraylen; i++)
if (TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP)
- {
- chain = argv->array[i]->u.u_c.chain;
- while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- if (chain->u.u_s.level >= 0)
- adjust_refcount (chain->u.u_s.level, increase);
- break;
- case CHAIN_FUNC:
- break;
- case CHAIN_ARGV:
- assert (chain->u.u_a.argv->inuse);
- arg_adjust_refcount (chain->u.u_a.argv, increase);
- break;
- default:
- assert (!"arg_adjust_refcount");
- abort ();
- }
- chain = chain->next;
- }
- }
+ {
+ chain = argv->array[i]->u.u_c.chain;
+ while (chain)
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (chain->u.u_s.level >= 0)
+ adjust_refcount (chain->u.u_s.level, increase);
+ break;
+ case CHAIN_FUNC:
+ break;
+ case CHAIN_ARGV:
+ assert (chain->u.u_a.argv->inuse);
+ arg_adjust_refcount (chain->u.u_a.argv, increase);
+ break;
+ default:
+ assert (!"arg_adjust_refcount");
+ abort ();
+ }
+ chain = chain->next;
+ }
+ }
adjust_refcount (argv->level, increase);
return result;
}
@@ -811,7 +811,7 @@ arg_token (macro_arguments *argv, unsigned int arg, int
*level, bool flatten)
{
token = argv->array[arg - 1];
if (flatten && TOKEN_DATA_TYPE (token) == TOKEN_FUNC)
- token = &empty_token;
+ token = &empty_token;
return token;
}
@@ -821,22 +821,22 @@ arg_token (macro_arguments *argv, unsigned int arg, int
*level, bool flatten)
{
token = argv->array[i];
if (TOKEN_DATA_TYPE (token) == TOKEN_COMP && token->u.u_c.wrapper)
- {
- token_chain *chain = token->u.u_c.chain;
- assert (!chain->next && chain->type == CHAIN_ARGV);
- if (arg <= (chain->u.u_a.argv->argc - chain->u.u_a.index
- - chain->u.u_a.skip_last))
- {
- token = arg_token (chain->u.u_a.argv,
- chain->u.u_a.index - 1 + arg, level,
- flatten || chain->u.u_a.flatten);
- break;
- }
- arg -= (chain->u.u_a.argv->argc - chain->u.u_a.index
- - chain->u.u_a.skip_last);
- }
+ {
+ token_chain *chain = token->u.u_c.chain;
+ assert (!chain->next && chain->type == CHAIN_ARGV);
+ if (arg <= (chain->u.u_a.argv->argc - chain->u.u_a.index
+ - chain->u.u_a.skip_last))
+ {
+ token = arg_token (chain->u.u_a.argv,
+ chain->u.u_a.index - 1 + arg, level,
+ flatten || chain->u.u_a.flatten);
+ break;
+ }
+ arg -= (chain->u.u_a.argv->argc - chain->u.u_a.index
+ - chain->u.u_a.skip_last);
+ }
else if (--arg == 0)
- break;
+ break;
}
return token;
}
@@ -855,13 +855,13 @@ arg_mark (macro_arguments *argv)
if (argv->wrapper)
for (i = 0; i < argv->arraylen; i++)
if (TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP
- && argv->array[i]->u.u_c.wrapper)
- {
- chain = argv->array[i]->u.u_c.chain;
- assert (!chain->next && chain->type == CHAIN_ARGV);
- if (!chain->u.u_a.argv->inuse)
- arg_mark (chain->u.u_a.argv);
- }
+ && argv->array[i]->u.u_c.wrapper)
+ {
+ chain = argv->array[i]->u.u_c.chain;
+ assert (!chain->next && chain->type == CHAIN_ARGV);
+ if (!chain->u.u_a.argv->inuse)
+ arg_mark (chain->u.u_a.argv);
+ }
}
/* Given ARGV, return how many arguments it refers to. */
@@ -928,31 +928,31 @@ arg_text (macro_arguments *argv, unsigned int arg, bool
flatten)
chain = token->u.u_c.chain;
obs = arg_scratch ();
while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
- break;
- case CHAIN_FUNC:
- if (flatten)
- break;
- assert (!"arg_text");
- abort ();
- case CHAIN_ARGV:
- assert (!chain->u.u_a.has_func || flatten || argv->flatten);
- arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes),
- flatten || argv->flatten || chain->u.u_a.flatten,
- NULL, NULL, NULL, false);
- break;
- default:
- assert (!"arg_text");
- abort ();
- }
- chain = chain->next;
- }
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
+ break;
+ case CHAIN_FUNC:
+ if (flatten)
+ break;
+ assert (!"arg_text");
+ abort ();
+ case CHAIN_ARGV:
+ assert (!chain->u.u_a.has_func || flatten || argv->flatten);
+ arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes),
+ flatten || argv->flatten || chain->u.u_a.flatten,
+ NULL, NULL, NULL, false);
+ break;
+ default:
+ assert (!"arg_text");
+ abort ();
+ }
+ chain = chain->next;
+ }
obstack_1grow (obs, '\0');
return (char *) obstack_finish (obs);
case TOKEN_FUNC:
@@ -985,8 +985,8 @@ arg_equal (macro_arguments *argv, unsigned int indexa,
unsigned int indexb)
if (TOKEN_DATA_TYPE (ta) == TOKEN_TEXT
&& TOKEN_DATA_TYPE (tb) == TOKEN_TEXT)
return (TOKEN_DATA_LEN (ta) == TOKEN_DATA_LEN (tb)
- && memcmp (TOKEN_DATA_TEXT (ta), TOKEN_DATA_TEXT (tb),
- TOKEN_DATA_LEN (ta)) == 0);
+ && memcmp (TOKEN_DATA_TEXT (ta), TOKEN_DATA_TEXT (tb),
+ TOKEN_DATA_LEN (ta)) == 0);
/* Convert both arguments to chains, if not one already. */
switch (TOKEN_DATA_TYPE (ta))
@@ -1034,76 +1034,76 @@ arg_equal (macro_arguments *argv, unsigned int indexa,
unsigned int indexb)
while (ca && cb)
{
if (ca->type == CHAIN_ARGV)
- {
- tmpa.next = NULL;
- tmpa.type = CHAIN_STR;
- tmpa.u.u_s.str = NULL;
- tmpa.u.u_s.len = 0;
- chain = &tmpa;
- arg_print (obs, ca->u.u_a.argv, ca->u.u_a.index,
- quote_cache (NULL, ca->quote_age, ca->u.u_a.quotes),
- argv->flatten || ca->u.u_a.flatten, &chain, NULL, NULL,
- false);
- assert (obstack_object_size (obs) == 0 && chain != &tmpa);
- chain->next = ca->next;
- ca = tmpa.next;
- continue;
- }
+ {
+ tmpa.next = NULL;
+ tmpa.type = CHAIN_STR;
+ tmpa.u.u_s.str = NULL;
+ tmpa.u.u_s.len = 0;
+ chain = &tmpa;
+ arg_print (obs, ca->u.u_a.argv, ca->u.u_a.index,
+ quote_cache (NULL, ca->quote_age, ca->u.u_a.quotes),
+ argv->flatten || ca->u.u_a.flatten, &chain, NULL, NULL,
+ false);
+ assert (obstack_object_size (obs) == 0 && chain != &tmpa);
+ chain->next = ca->next;
+ ca = tmpa.next;
+ continue;
+ }
if (cb->type == CHAIN_ARGV)
- {
- tmpb.next = NULL;
- tmpb.type = CHAIN_STR;
- tmpb.u.u_s.str = NULL;
- tmpb.u.u_s.len = 0;
- chain = &tmpb;
- arg_print (obs, cb->u.u_a.argv, cb->u.u_a.index,
- quote_cache (NULL, cb->quote_age, cb->u.u_a.quotes),
- argv->flatten || cb->u.u_a.flatten, &chain, NULL, NULL,
- false);
- assert (obstack_object_size (obs) == 0 && chain != &tmpb);
- chain->next = cb->next;
- cb = tmpb.next;
- continue;
- }
+ {
+ tmpb.next = NULL;
+ tmpb.type = CHAIN_STR;
+ tmpb.u.u_s.str = NULL;
+ tmpb.u.u_s.len = 0;
+ chain = &tmpb;
+ arg_print (obs, cb->u.u_a.argv, cb->u.u_a.index,
+ quote_cache (NULL, cb->quote_age, cb->u.u_a.quotes),
+ argv->flatten || cb->u.u_a.flatten, &chain, NULL, NULL,
+ false);
+ assert (obstack_object_size (obs) == 0 && chain != &tmpb);
+ chain->next = cb->next;
+ cb = tmpb.next;
+ continue;
+ }
if (ca->type == CHAIN_FUNC)
- {
- if (cb->type != CHAIN_FUNC || ca->u.func != cb->u.func)
- return false;
- ca = ca->next;
- cb = cb->next;
- continue;
- }
+ {
+ if (cb->type != CHAIN_FUNC || ca->u.func != cb->u.func)
+ return false;
+ ca = ca->next;
+ cb = cb->next;
+ continue;
+ }
assert (ca->type == CHAIN_STR && cb->type == CHAIN_STR);
if (ca->u.u_s.len == cb->u.u_s.len)
- {
- if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
- return false;
- ca = ca->next;
- cb = cb->next;
- }
+ {
+ if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
+ return false;
+ ca = ca->next;
+ cb = cb->next;
+ }
else if (ca->u.u_s.len < cb->u.u_s.len)
- {
- if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
- return false;
- tmpb.next = cb->next;
- tmpb.type = CHAIN_STR;
- tmpb.u.u_s.str = cb->u.u_s.str + ca->u.u_s.len;
- tmpb.u.u_s.len = cb->u.u_s.len - ca->u.u_s.len;
- ca = ca->next;
- cb = &tmpb;
- }
+ {
+ if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
+ return false;
+ tmpb.next = cb->next;
+ tmpb.type = CHAIN_STR;
+ tmpb.u.u_s.str = cb->u.u_s.str + ca->u.u_s.len;
+ tmpb.u.u_s.len = cb->u.u_s.len - ca->u.u_s.len;
+ ca = ca->next;
+ cb = &tmpb;
+ }
else
- {
- assert (ca->u.u_s.len > cb->u.u_s.len);
- if (memcmp (ca->u.u_s.str, cb->u.u_s.str, cb->u.u_s.len) != 0)
- return false;
- tmpa.next = ca->next;
- tmpa.type = CHAIN_STR;
- tmpa.u.u_s.str = ca->u.u_s.str + cb->u.u_s.len;
- tmpa.u.u_s.len = ca->u.u_s.len - cb->u.u_s.len;
- ca = &tmpa;
- cb = cb->next;
- }
+ {
+ assert (ca->u.u_s.len > cb->u.u_s.len);
+ if (memcmp (ca->u.u_s.str, cb->u.u_s.str, cb->u.u_s.len) != 0)
+ return false;
+ tmpa.next = ca->next;
+ tmpa.type = CHAIN_STR;
+ tmpa.u.u_s.str = ca->u.u_s.str + cb->u.u_s.len;
+ tmpa.u.u_s.len = ca->u.u_s.len - cb->u.u_s.len;
+ ca = &tmpa;
+ cb = cb->next;
+ }
}
/* If we get this far, the two tokens are equal only if both chains
@@ -1155,37 +1155,37 @@ arg_len (macro_arguments *argv, unsigned int arg, bool
flatten)
chain = token->u.u_c.chain;
len = 0;
while (chain)
- {
- unsigned int i;
- unsigned int limit;
- const string_pair *quotes;
- switch (chain->type)
- {
- case CHAIN_STR:
- len += chain->u.u_s.len;
- break;
- case CHAIN_FUNC:
- assert (flatten);
- break;
- case CHAIN_ARGV:
- i = chain->u.u_a.index;
- limit = chain->u.u_a.argv->argc - i - chain->u.u_a.skip_last;
- quotes = quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes);
- assert (limit);
- if (quotes)
- len += (quotes->len1 + quotes->len2) * limit;
- len += limit - 1;
- while (limit--)
- len += arg_len (chain->u.u_a.argv, i++,
- flatten || chain->u.u_a.flatten);
- break;
- default:
- assert (!"arg_len");
- abort ();
- }
- chain = chain->next;
- }
+ {
+ unsigned int i;
+ unsigned int limit;
+ const string_pair *quotes;
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ len += chain->u.u_s.len;
+ break;
+ case CHAIN_FUNC:
+ assert (flatten);
+ break;
+ case CHAIN_ARGV:
+ i = chain->u.u_a.index;
+ limit = chain->u.u_a.argv->argc - i - chain->u.u_a.skip_last;
+ quotes = quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes);
+ assert (limit);
+ if (quotes)
+ len += (quotes->len1 + quotes->len2) * limit;
+ len += limit - 1;
+ while (limit--)
+ len += arg_len (chain->u.u_a.argv, i++,
+ flatten || chain->u.u_a.flatten);
+ break;
+ default:
+ assert (!"arg_len");
+ abort ();
+ }
+ chain = chain->next;
+ }
assert (len || flatten);
return len;
case TOKEN_FUNC:
@@ -1233,8 +1233,8 @@ arg_scratch (void)
specified. */
bool
arg_print (struct obstack *obs, macro_arguments *argv, unsigned int arg,
- const string_pair *quotes, bool flatten, token_chain **chainp,
- const char *sep, size_t *max_len, bool quote_each)
+ const string_pair *quotes, bool flatten, token_chain **chainp,
+ const char *sep, size_t *max_len, bool quote_each)
{
size_t len = max_len ? *max_len : INT_MAX;
unsigned int i;
@@ -1254,71 +1254,71 @@ arg_print (struct obstack *obs, macro_arguments *argv,
unsigned int arg,
for (i = arg; i < argv->argc; i++)
{
if (quote_each && max_len)
- len = *max_len;
+ len = *max_len;
if (use_sep && shipout_string_trunc (obs, sep, sep_len, plen))
- return true;
+ return true;
use_sep = true;
token = arg_token (argv, i, NULL, flatten);
switch (TOKEN_DATA_TYPE (token))
- {
- case TOKEN_TEXT:
- if (quotes && shipout_string_trunc (obs, quotes->str1, quotes->len1,
- plen))
- return true;
- if (shipout_string_trunc (obs, TOKEN_DATA_TEXT (token),
- TOKEN_DATA_LEN (token), &len)
- && !quote_each)
- return true;
- if (quotes && shipout_string_trunc (obs, quotes->str2, quotes->len2,
- plen))
- return true;
- break;
- case TOKEN_COMP:
- if (quotes && shipout_string_trunc (obs, quotes->str1, quotes->len1,
- plen))
- return true;
- chain = token->u.u_c.chain;
- done = false;
- while (chain && !done)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- if (shipout_string_trunc (obs, chain->u.u_s.str,
- chain->u.u_s.len, &len))
- done = true;
- break;
- case CHAIN_FUNC:
- func_print (obs, find_builtin_by_addr (chain->u.func),
- flatten, chainp, quotes);
- break;
- case CHAIN_ARGV:
- if (arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes),
- flatten, chainp, NULL, &len, false))
- done = true;
- break;
- default:
- assert (!"arg_print");
- abort ();
- }
- chain = chain->next;
- }
- if (done && !quote_each)
- return true;
- if (quotes && shipout_string_trunc (obs, quotes->str2, quotes->len2,
- plen))
- return true;
- break;
- case TOKEN_FUNC:
- func_print (obs, find_builtin_by_addr (TOKEN_DATA_FUNC (token)),
- flatten, chainp, quotes);
- break;
- default:
- assert (!"arg_print");
- abort ();
- }
+ {
+ case TOKEN_TEXT:
+ if (quotes && shipout_string_trunc (obs, quotes->str1, quotes->len1,
+ plen))
+ return true;
+ if (shipout_string_trunc (obs, TOKEN_DATA_TEXT (token),
+ TOKEN_DATA_LEN (token), &len)
+ && !quote_each)
+ return true;
+ if (quotes && shipout_string_trunc (obs, quotes->str2, quotes->len2,
+ plen))
+ return true;
+ break;
+ case TOKEN_COMP:
+ if (quotes && shipout_string_trunc (obs, quotes->str1, quotes->len1,
+ plen))
+ return true;
+ chain = token->u.u_c.chain;
+ done = false;
+ while (chain && !done)
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ if (shipout_string_trunc (obs, chain->u.u_s.str,
+ chain->u.u_s.len, &len))
+ done = true;
+ break;
+ case CHAIN_FUNC:
+ func_print (obs, find_builtin_by_addr (chain->u.func),
+ flatten, chainp, quotes);
+ break;
+ case CHAIN_ARGV:
+ if (arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes),
+ flatten, chainp, NULL, &len, false))
+ done = true;
+ break;
+ default:
+ assert (!"arg_print");
+ abort ();
+ }
+ chain = chain->next;
+ }
+ if (done && !quote_each)
+ return true;
+ if (quotes && shipout_string_trunc (obs, quotes->str2, quotes->len2,
+ plen))
+ return true;
+ break;
+ case TOKEN_FUNC:
+ func_print (obs, find_builtin_by_addr (TOKEN_DATA_FUNC (token)),
+ flatten, chainp, quotes);
+ break;
+ default:
+ assert (!"arg_print");
+ abort ();
+ }
}
if (max_len)
*max_len = len;
@@ -1334,8 +1334,8 @@ arg_print (struct obstack *obs, macro_arguments *argv,
unsigned int arg,
NULL when wrapping ARGV is trivially empty. */
static token_data *
make_argv_ref_token (token_data *token, struct obstack *obs, int level,
- macro_arguments *argv, unsigned int arg, bool flatten,
- const string_pair *quotes)
+ macro_arguments *argv, unsigned int arg, bool flatten,
+ const string_pair *quotes)
{
token_chain *chain;
@@ -1351,35 +1351,35 @@ make_argv_ref_token (token_data *token, struct obstack
*obs, int level,
{
unsigned int i;
for (i = 0; i < argv->arraylen; i++)
- {
- if ((TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP
- && argv->array[i]->u.u_c.wrapper)
- || level >= 0)
- break;
- if (arg == 1)
- {
- push_arg_quote (obs, argv, i + 1, quotes);
- obstack_1grow (obs, ',');
- }
- else
- arg--;
- }
+ {
+ if ((TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP
+ && argv->array[i]->u.u_c.wrapper)
+ || level >= 0)
+ break;
+ if (arg == 1)
+ {
+ push_arg_quote (obs, argv, i + 1, quotes);
+ obstack_1grow (obs, ',');
+ }
+ else
+ arg--;
+ }
assert (i < argv->arraylen);
if (i + 1 == argv->arraylen)
- {
- assert (TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP
- && argv->array[i]->u.u_c.wrapper);
- chain = argv->array[i]->u.u_c.chain;
- assert (!chain->next && chain->type == CHAIN_ARGV
- && !chain->u.u_a.skip_last);
- argv = chain->u.u_a.argv;
- arg += chain->u.u_a.index - 1;
- }
+ {
+ assert (TOKEN_DATA_TYPE (argv->array[i]) == TOKEN_COMP
+ && argv->array[i]->u.u_c.wrapper);
+ chain = argv->array[i]->u.u_c.chain;
+ assert (!chain->next && chain->type == CHAIN_ARGV
+ && !chain->u.u_a.skip_last);
+ argv = chain->u.u_a.argv;
+ arg += chain->u.u_a.index - 1;
+ }
else
- {
- arg += i;
- break;
- }
+ {
+ arg += i;
+ break;
+ }
}
make_text_link (obs, &token->u.u_c.chain, &token->u.u_c.end);
@@ -1413,7 +1413,7 @@ make_argv_ref_token (token_data *token, struct obstack
*obs, int level,
regardless of global trace state. */
macro_arguments *
make_argv_ref (macro_arguments *argv, const char *argv0, size_t argv0_len,
- bool flatten, bool trace)
+ bool flatten, bool trace)
{
macro_arguments *new_argv;
token_data *token;
@@ -1424,12 +1424,12 @@ make_argv_ref (macro_arguments *argv, const char
*argv0, size_t argv0_len,
info = (call_info *) obstack_copy (obs, argv->info, sizeof *info);
new_token = (token_data *) obstack_alloc (obs, sizeof *token);
token = make_argv_ref_token (new_token, obs, expansion_level - 1, argv, 2,
- flatten, NULL);
+ flatten, NULL);
if (!token)
{
obstack_free (obs, new_token);
new_argv = (macro_arguments *)
- obstack_alloc (obs, offsetof (macro_arguments, array));
+ obstack_alloc (obs, offsetof (macro_arguments, array));
new_argv->arraylen = 0;
new_argv->wrapper = false;
new_argv->has_ref = false;
@@ -1439,7 +1439,7 @@ make_argv_ref (macro_arguments *argv, const char *argv0,
size_t argv0_len,
else
{
new_argv = (macro_arguments *)
- obstack_alloc (obs, offsetof (macro_arguments, array) + sizeof token);
+ obstack_alloc (obs, offsetof (macro_arguments, array) + sizeof token);
new_argv->arraylen = 1;
new_argv->array[0] = token;
new_argv->wrapper = true;
@@ -1466,7 +1466,7 @@ push_arg (struct obstack *obs, macro_arguments *argv,
unsigned int arg)
if (arg == 0)
{
/* Always push copy of arg 0, since its lifetime is not
- guaranteed beyond expand_macro. */
+ guaranteed beyond expand_macro. */
assert (argv->info);
obstack_grow (obs, argv->info->name, argv->info->name_len);
return;
@@ -1481,7 +1481,7 @@ push_arg (struct obstack *obs, macro_arguments *argv,
unsigned int arg)
delimiters that were in effect when the reference was created. */
void
push_arg_quote (struct obstack *obs, macro_arguments *argv, unsigned int arg,
- const string_pair *quotes)
+ const string_pair *quotes)
{
int level;
token_data *token = arg_token (argv, arg, &level, false);
@@ -1515,7 +1515,7 @@ push_args (struct obstack *obs, macro_arguments *argv,
bool skip, bool quote)
}
token = make_argv_ref_token (&td, obs, -1, argv, i, argv->flatten,
- quote ? &curr_quote : NULL);
+ quote ? &curr_quote : NULL);
assert (token);
if (push_token (token, -1, argv->inuse))
arg_mark (argv);
@@ -1541,45 +1541,45 @@ wrap_args (macro_arguments *argv)
for (i = 1; i < (no_gnu_extensions ? 2 : argv->argc); i++)
{
if (i != 1)
- obstack_1grow (obs, ' ');
+ obstack_1grow (obs, ' ');
token = arg_token (argv, i, NULL, false);
switch (TOKEN_DATA_TYPE (token))
- {
- case TOKEN_TEXT:
- obstack_grow (obs, TOKEN_DATA_TEXT (token), TOKEN_DATA_LEN (token));
- break;
- case TOKEN_FUNC:
- append_macro (obs, TOKEN_DATA_FUNC (token), NULL, end);
- break;
- case TOKEN_COMP:
- chain = token->u.u_c.chain;
- while (chain)
- {
- switch (chain->type)
- {
- case CHAIN_STR:
- obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
- break;
- case CHAIN_FUNC:
- append_macro (obs, chain->u.func, NULL, end);
- break;
- case CHAIN_ARGV:
- arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
- quote_cache (NULL, chain->quote_age,
- chain->u.u_a.quotes),
- chain->u.u_a.flatten, end, NULL, NULL, false);
- break;
- default:
- assert (!"wrap_args");
- abort ();
- }
- chain = chain->next;
- }
- break;
- default:
- assert (!"wrap_args");
- abort ();
- }
+ {
+ case TOKEN_TEXT:
+ obstack_grow (obs, TOKEN_DATA_TEXT (token), TOKEN_DATA_LEN (token));
+ break;
+ case TOKEN_FUNC:
+ append_macro (obs, TOKEN_DATA_FUNC (token), NULL, end);
+ break;
+ case TOKEN_COMP:
+ chain = token->u.u_c.chain;
+ while (chain)
+ {
+ switch (chain->type)
+ {
+ case CHAIN_STR:
+ obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
+ break;
+ case CHAIN_FUNC:
+ append_macro (obs, chain->u.func, NULL, end);
+ break;
+ case CHAIN_ARGV:
+ arg_print (obs, chain->u.u_a.argv, chain->u.u_a.index,
+ quote_cache (NULL, chain->quote_age,
+ chain->u.u_a.quotes),
+ chain->u.u_a.flatten, end, NULL, NULL, false);
+ break;
+ default:
+ assert (!"wrap_args");
+ abort ();
+ }
+ chain = chain->next;
+ }
+ break;
+ default:
+ assert (!"wrap_args");
+ abort ();
+ }
}
push_wrapup_finish ();
}
diff --git a/src/output.c b/src/output.c
index 07473ce..29b0809 100644
--- a/src/output.c
+++ b/src/output.c
@@ -24,6 +24,7 @@
#include <sys/stat.h>
#include "gl_avltree_oset.h"
+#include "gl_xoset.h"
/* Size of initial in-memory buffer size for diversions. Small diversions
would usually fit in. */
@@ -57,9 +58,9 @@ struct m4_diversion
{
union
{
- FILE *file; /* Diversion file on disk. */
- char *buffer; /* Malloc'd diversion buffer. */
- m4_diversion *next; /* Free-list pointer */
+ FILE *file; /* Diversion file on disk. */
+ char *buffer; /* Malloc'd diversion buffer. */
+ m4_diversion *next; /* Free-list pointer */
} u;
int divnum; /* Which diversion this represents. */
int size; /* Usable size before reallocation. */
@@ -161,16 +162,16 @@ cleanup_tmpfile (void)
const void *elt;
gl_oset_iterator_t iter = gl_oset_iterator (diversion_table);
while (gl_oset_iterator_next (&iter, &elt))
- {
- m4_diversion *diversion = (m4_diversion *) elt;
- if (!diversion->size && diversion->u.file
- && close_stream_temp (diversion->u.file) != 0)
- {
- m4_warn (errno, NULL,
- _("cannot clean temporary file for diversion"));
- fail = true;
- }
- }
+ {
+ m4_diversion *diversion = (m4_diversion *) elt;
+ if (!diversion->size && diversion->u.file
+ && close_stream_temp (diversion->u.file) != 0)
+ {
+ m4_warn (errno, NULL,
+ _("cannot clean temporary file for diversion"));
+ fail = true;
+ }
+ }
gl_oset_iterator_free (&iter);
}
@@ -192,12 +193,12 @@ m4_tmpname (int divnum)
obstack_printf (&diversion_storage, "%s/m4-", output_temp_dir->dir_name);
offset = obstack_object_size (&diversion_storage);
buffer = (char *) obstack_alloc (&diversion_storage,
- INT_BUFSIZE_BOUND (divnum));
+ INT_BUFSIZE_BOUND (divnum));
}
assert (0 < divnum);
if (snprintf (&buffer[offset], INT_BUFSIZE_BOUND (divnum), "%d", divnum) < 0)
m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot create temporary file for diversion"));
+ _("cannot create temporary file for diversion"));
return buffer;
}
@@ -218,8 +219,8 @@ m4_tmpfile (int divnum)
{
output_temp_dir = create_temp_dir ("m4-", NULL, true);
if (output_temp_dir == NULL)
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot create temporary file for diversion"));
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot create temporary file for diversion"));
atexit (cleanup_tmpfile);
}
name = m4_tmpname (divnum);
@@ -229,7 +230,7 @@ m4_tmpfile (int divnum)
{
unregister_temp_file (output_temp_dir, name);
m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot create temporary file for diversion"));
+ _("cannot create temporary file for diversion"));
}
else if (set_cloexec_flag (fileno (file), true) != 0)
m4_warn (errno, NULL, _("cannot protect diversion across forks"));
@@ -250,16 +251,16 @@ m4_tmpopen (int divnum, bool reread)
if (tmp_file1_owner == divnum)
{
if (reread && fseeko (tmp_file1, 0, SEEK_SET) != 0)
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot seek within diversion"));
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot seek within diversion"));
tmp_file2_recent = false;
return tmp_file1;
}
else if (tmp_file2_owner == divnum)
{
if (reread && fseeko (tmp_file2, 0, SEEK_SET) != 0)
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot seek within diversion"));
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot seek within diversion"));
tmp_file2_recent = true;
return tmp_file2;
}
@@ -268,14 +269,14 @@ m4_tmpopen (int divnum, bool reread)
file = fopen_temp (name, O_BINARY ? "rb+" : "r+");
if (file == NULL)
m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot create temporary file for diversion"));
+ _("cannot create temporary file for diversion"));
else if (set_cloexec_flag (fileno (file), true) != 0)
m4_warn (errno, NULL, _("cannot protect diversion across forks"));
/* Update mode starts at the beginning of the stream, but sometimes
we want the end. */
else if (!reread && fseeko (file, 0, SEEK_END) != 0)
m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot seek within diversion"));
+ _("cannot seek within diversion"));
return file;
}
@@ -291,19 +292,19 @@ m4_tmpclose (FILE *file, int divnum)
if (divnum != tmp_file1_owner && divnum != tmp_file2_owner)
{
if (tmp_file2_recent)
- {
- if (tmp_file1_owner)
- result = close_stream_temp (tmp_file1);
- tmp_file1 = file;
- tmp_file1_owner = divnum;
- }
+ {
+ if (tmp_file1_owner)
+ result = close_stream_temp (tmp_file1);
+ tmp_file1 = file;
+ tmp_file1_owner = divnum;
+ }
else
- {
- if (tmp_file2_owner)
- result = close_stream_temp (tmp_file2);
- tmp_file2 = file;
- tmp_file2_owner = divnum;
- }
+ {
+ if (tmp_file2_owner)
+ result = close_stream_temp (tmp_file2);
+ tmp_file2 = file;
+ tmp_file2_owner = divnum;
+ }
}
return result;
}
@@ -316,14 +317,14 @@ m4_tmpremove (int divnum)
{
int result = close_stream_temp (tmp_file1);
if (result)
- return result;
+ return result;
tmp_file1_owner = 0;
}
else if (divnum == tmp_file2_owner)
{
int result = close_stream_temp (tmp_file2);
if (result)
- return result;
+ return result;
tmp_file2_owner = 0;
}
return cleanup_temp_file (output_temp_dir, m4_tmpname (divnum));
@@ -343,33 +344,33 @@ m4_tmprename (int oldnum, int newnum)
{
/* Be careful of mingw, which can't rename an open file. */
if (RENAME_OPEN_FILE_WORKS)
- tmp_file1_owner = newnum;
+ tmp_file1_owner = newnum;
else
- {
- if (close_stream_temp (tmp_file1))
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot close temporary file for diversion"));
- tmp_file1_owner = 0;
- }
+ {
+ if (close_stream_temp (tmp_file1))
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot close temporary file for diversion"));
+ tmp_file1_owner = 0;
+ }
}
else if (oldnum == tmp_file2_owner)
{
/* Be careful of mingw, which can't rename an open file. */
if (RENAME_OPEN_FILE_WORKS)
- tmp_file2_owner = newnum;
+ tmp_file2_owner = newnum;
else
- {
- if (close_stream_temp (tmp_file2))
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot close temporary file for diversion"));
- tmp_file2_owner = 0;
- }
+ {
+ if (close_stream_temp (tmp_file2))
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot close temporary file for diversion"));
+ tmp_file2_owner = 0;
+ }
}
/* Either it is safe to rename an open file, or no one should have
oldname open at this point. */
if (rename (oldname, newname))
m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot create temporary file for diversion"));
+ _("cannot create temporary file for diversion"));
unregister_temp_file (output_temp_dir, oldname);
free (oldname);
return m4_tmpopen (newnum, false);
@@ -384,7 +385,7 @@ void
output_init (void)
{
diversion_table = gl_oset_create_empty (GL_AVLTREE_OSET, cmp_diversion_CB,
- NULL);
+ NULL);
div0.u.file = stdout;
output_diversion = &div0;
output_file = stdout;
@@ -445,30 +446,30 @@ make_room_for (int length)
const void *elt;
/* Find out the buffer having most data, in view of flushing it to
- disk. Fake the current buffer as having already received the
- projected data, while making the selection. So, if it is
- selected indeed, we will flush it smaller, before it grows. */
+ disk. Fake the current buffer as having already received the
+ projected data, while making the selection. So, if it is
+ selected indeed, we will flush it smaller, before it grows. */
selected_diversion = output_diversion;
selected_used = output_diversion->used + length;
iter = gl_oset_iterator (diversion_table);
while (gl_oset_iterator_next (&iter, &elt))
- {
- diversion = (m4_diversion *) elt;
- if (diversion->used > selected_used)
- {
- selected_diversion = diversion;
- selected_used = diversion->used;
- }
- }
+ {
+ diversion = (m4_diversion *) elt;
+ if (diversion->used > selected_used)
+ {
+ selected_diversion = diversion;
+ selected_used = diversion->used;
+ }
+ }
gl_oset_iterator_free (&iter);
/* Create a temporary file, write the in-memory buffer of the
- diversion to this file, then release the buffer. Zero the
- diversion before doing anything that can exit () (including
- m4_tmpfile), so that the atexit handler doesn't try to close
- a garbage pointer as a file. */
+ diversion to this file, then release the buffer. Zero the
+ diversion before doing anything that can exit () (including
+ m4_tmpfile), so that the atexit handler doesn't try to close
+ a garbage pointer as a file. */
selected_buffer = selected_diversion->u.buffer;
total_buffer_size -= selected_diversion->size;
@@ -477,13 +478,13 @@ make_room_for (int length)
selected_diversion->u.file = m4_tmpfile (selected_diversion->divnum);
if (selected_diversion->used > 0)
- {
- count = fwrite (selected_buffer, (size_t) selected_diversion->used,
- 1, selected_diversion->u.file);
- if (count != 1)
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot flush diversion to temporary file"));
- }
+ {
+ count = fwrite (selected_buffer, (size_t) selected_diversion->used,
+ 1, selected_diversion->u.file);
+ if (count != 1)
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot flush diversion to temporary file"));
+ }
/* Reclaim the buffer space for other diversions. */
@@ -505,20 +506,20 @@ make_room_for (int length)
{
/* Close any selected file since it is not the current diversion. */
if (selected_diversion)
- {
- FILE *file = selected_diversion->u.file;
- selected_diversion->u.file = NULL;
- if (m4_tmpclose (file, selected_diversion->divnum) != 0)
- m4_warn (errno, NULL,
- _("cannot close temporary file for diversion"));
- }
+ {
+ FILE *file = selected_diversion->u.file;
+ selected_diversion->u.file = NULL;
+ if (m4_tmpclose (file, selected_diversion->divnum) != 0)
+ m4_warn (errno, NULL,
+ _("cannot close temporary file for diversion"));
+ }
/* The current buffer may be safely reallocated. */
{
- char *buffer = output_diversion->u.buffer;
- output_diversion->u.buffer = xcharalloc ((size_t) wanted_size);
- memcpy (output_diversion->u.buffer, buffer, output_diversion->used);
- free (buffer);
+ char *buffer = output_diversion->u.buffer;
+ output_diversion->u.buffer = xcharalloc ((size_t) wanted_size);
+ memcpy (output_diversion->u.buffer, buffer, output_diversion->used);
+ free (buffer);
}
total_buffer_size += wanted_size - output_diversion->size;
@@ -576,7 +577,7 @@ output_text (const char *text, int length)
{
count = fwrite (text, length, 1, output_file);
if (count != 1)
- m4_error (EXIT_FAILURE, errno, NULL, _("error copying inserted file"));
+ m4_error (EXIT_FAILURE, errno, NULL, _("error copying inserted file"));
}
else
{
@@ -625,7 +626,7 @@ divert_text (struct obstack *obs, const char *text, int
length, int line)
switch (length)
{
- /* In-line short texts. */
+ /* In-line short texts. */
case 8: OUTPUT_CHARACTER (*text); text++;
case 7: OUTPUT_CHARACTER (*text); text++;
@@ -636,66 +637,66 @@ divert_text (struct obstack *obs, const char *text, int
length, int line)
case 2: OUTPUT_CHARACTER (*text); text++;
case 1: OUTPUT_CHARACTER (*text);
case 0:
- return;
+ return;
- /* Optimize longer texts. */
+ /* Optimize longer texts. */
default:
- output_text (text, length);
+ output_text (text, length);
}
else
{
/* Check for syncline only at the start of a token. Multiline
- tokens, and tokens that are out of sync but in the middle of
- the line, must wait until the next raw newline triggers a
- syncline. */
+ tokens, and tokens that are out of sync but in the middle of
+ the line, must wait until the next raw newline triggers a
+ syncline. */
if (start_of_output_line)
- {
- start_of_output_line = false;
- output_current_line++;
+ {
+ start_of_output_line = false;
+ output_current_line++;
#ifdef DEBUG_OUTPUT
- xfprintf (stderr, "DEBUG: line %d, cur %d, cur out %d\n",
- line, current_line, output_current_line);
+ xfprintf (stderr, "DEBUG: line %d, cur %d, cur out %d\n",
+ line, current_line, output_current_line);
#endif
- /* Output a `#line NUM' synchronization directive if needed.
- If output_current_line was previously given a negative
- value (invalidated), output `#line NUM "FILE"' instead. */
-
- if (output_current_line != line)
- {
- static char line_buf[sizeof "#line " + INT_BUFSIZE_BOUND (line)];
- sprintf (line_buf, "#line %d", line);
- output_text (line_buf, strlen (line_buf));
- assert (strlen (line_buf) < sizeof line_buf);
- if (output_current_line < 1 && current_file[0] != '\0')
- {
- OUTPUT_CHARACTER (' ');
- OUTPUT_CHARACTER ('"');
- output_text (current_file, strlen (current_file));
- OUTPUT_CHARACTER ('"');
- }
- OUTPUT_CHARACTER ('\n');
- output_current_line = line;
- }
- }
+ /* Output a `#line NUM' synchronization directive if needed.
+ If output_current_line was previously given a negative
+ value (invalidated), output `#line NUM "FILE"' instead. */
+
+ if (output_current_line != line)
+ {
+ static char line_buf[sizeof "#line " + INT_BUFSIZE_BOUND (line)];
+ sprintf (line_buf, "#line %d", line);
+ output_text (line_buf, strlen (line_buf));
+ assert (strlen (line_buf) < sizeof line_buf);
+ if (output_current_line < 1 && current_file[0] != '\0')
+ {
+ OUTPUT_CHARACTER (' ');
+ OUTPUT_CHARACTER ('"');
+ output_text (current_file, strlen (current_file));
+ OUTPUT_CHARACTER ('"');
+ }
+ OUTPUT_CHARACTER ('\n');
+ output_current_line = line;
+ }
+ }
/* Output the token, and track embedded newlines. */
for (; length-- > 0; text++)
- {
- if (start_of_output_line)
- {
- start_of_output_line = false;
- output_current_line++;
+ {
+ if (start_of_output_line)
+ {
+ start_of_output_line = false;
+ output_current_line++;
#ifdef DEBUG_OUTPUT
- xfprintf (stderr, "DEBUG: line %d, cur %d, cur out %d\n",
- line, current_line, output_current_line);
+ xfprintf (stderr, "DEBUG: line %d, cur %d, cur out %d\n",
+ line, current_line, output_current_line);
#endif
- }
- OUTPUT_CHARACTER (*text);
- if (*text == '\n')
- start_of_output_line = true;
- }
+ }
+ OUTPUT_CHARACTER (*text);
+ if (*text == '\n')
+ start_of_output_line = true;
+ }
}
}
@@ -706,7 +707,7 @@ divert_text (struct obstack *obs, const char *text, int
length, int line)
appropriate. */
bool
shipout_string_trunc (struct obstack *obs, const char *str, size_t len,
- size_t *max_len)
+ size_t *max_len)
{
size_t max = max_len ? *max_len : INT_MAX;
@@ -749,23 +750,23 @@ make_diversion (int divnum)
if (output_diversion)
{
if (!output_diversion->size && !output_diversion->u.file)
- {
- assert (!output_diversion->used);
- if (!gl_oset_remove (diversion_table, output_diversion))
- assert (false);
- output_diversion->u.next = free_list;
- free_list = output_diversion;
- }
+ {
+ assert (!output_diversion->used);
+ if (!gl_oset_remove (diversion_table, output_diversion))
+ assert (false);
+ output_diversion->u.next = free_list;
+ free_list = output_diversion;
+ }
else if (output_diversion->size)
- output_diversion->used = output_diversion->size - output_unused;
+ output_diversion->used = output_diversion->size - output_unused;
else if (output_diversion->used)
- {
- FILE *file = output_diversion->u.file;
- output_diversion->u.file = NULL;
- if (m4_tmpclose (file, output_diversion->divnum) != 0)
- m4_warn (errno, NULL,
- _("cannot close temporary file for diversion"));
- }
+ {
+ FILE *file = output_diversion->u.file;
+ output_diversion->u.file = NULL;
+ if (m4_tmpclose (file, output_diversion->divnum) != 0)
+ m4_warn (errno, NULL,
+ _("cannot close temporary file for diversion"));
+ }
output_diversion = NULL;
output_file = NULL;
output_cursor = NULL;
@@ -783,28 +784,28 @@ make_diversion (int divnum)
{
const void *elt;
if (gl_oset_search_atleast (diversion_table, threshold_diversion_CB,
- &divnum, &elt))
- {
- m4_diversion *temp = (m4_diversion *) elt;
- if (temp->divnum == divnum)
- diversion = temp;
- }
+ &divnum, &elt))
+ {
+ m4_diversion *temp = (m4_diversion *) elt;
+ if (temp->divnum == divnum)
+ diversion = temp;
+ }
}
if (diversion == NULL)
{
/* First time visiting this diversion. */
if (free_list)
- {
- diversion = free_list;
- free_list = diversion->u.next;
- }
+ {
+ diversion = free_list;
+ free_list = diversion->u.next;
+ }
else
- {
- diversion = (m4_diversion *) obstack_alloc (&diversion_storage,
- sizeof *diversion);
- diversion->size = 0;
- diversion->used = 0;
- }
+ {
+ diversion = (m4_diversion *) obstack_alloc (&diversion_storage,
+ sizeof *diversion);
+ diversion->size = 0;
+ diversion->used = 0;
+ }
diversion->u.file = NULL;
diversion->divnum = divnum;
gl_oset_add (diversion_table, diversion);
@@ -819,8 +820,8 @@ make_diversion (int divnum)
else
{
if (!output_diversion->u.file && output_diversion->used)
- output_diversion->u.file = m4_tmpopen (output_diversion->divnum,
- false);
+ output_diversion->u.file = m4_tmpopen (output_diversion->divnum,
+ false);
output_file = output_diversion->u.file;
}
output_current_line = -1;
@@ -847,9 +848,9 @@ insert_file (FILE *file)
{
length = fread (buffer, 1, sizeof buffer, file);
if (ferror (file))
- m4_error (EXIT_FAILURE, errno, NULL, _("error reading inserted file"));
+ m4_error (EXIT_FAILURE, errno, NULL, _("error reading inserted file"));
if (length == 0)
- break;
+ break;
output_text (buffer, length);
}
}
@@ -868,47 +869,47 @@ insert_diversion_helper (m4_diversion *diversion)
if (output_diversion)
{
if (diversion->size)
- {
- if (!output_diversion->u.file)
- {
- /* Transferring diversion metadata is faster than
- copying contents. */
- assert (!output_diversion->used && output_diversion != &div0
- && !output_file);
- output_diversion->u.buffer = diversion->u.buffer;
- output_diversion->size = diversion->size;
- output_cursor = diversion->u.buffer + diversion->used;
- output_unused = diversion->size - diversion->used;
- diversion->u.buffer = NULL;
- }
- else
- {
- /* Avoid double-charging the total in-memory size when
- transferring from one in-memory diversion to
- another. */
- total_buffer_size -= diversion->size;
- output_text (diversion->u.buffer, diversion->used);
- }
- }
+ {
+ if (!output_diversion->u.file)
+ {
+ /* Transferring diversion metadata is faster than
+ copying contents. */
+ assert (!output_diversion->used && output_diversion != &div0
+ && !output_file);
+ output_diversion->u.buffer = diversion->u.buffer;
+ output_diversion->size = diversion->size;
+ output_cursor = diversion->u.buffer + diversion->used;
+ output_unused = diversion->size - diversion->used;
+ diversion->u.buffer = NULL;
+ }
+ else
+ {
+ /* Avoid double-charging the total in-memory size when
+ transferring from one in-memory diversion to
+ another. */
+ total_buffer_size -= diversion->size;
+ output_text (diversion->u.buffer, diversion->used);
+ }
+ }
else if (!output_diversion->u.file)
- {
- /* Transferring diversion metadata is faster than copying
- contents. */
- assert (!output_diversion->used && output_diversion != &div0
- && !output_file);
- output_diversion->u.file = m4_tmprename (diversion->divnum,
- output_diversion->divnum);
- output_diversion->used = 1;
- output_file = output_diversion->u.file;
- diversion->u.file = NULL;
- diversion->size = 1;
- }
+ {
+ /* Transferring diversion metadata is faster than copying
+ contents. */
+ assert (!output_diversion->used && output_diversion != &div0
+ && !output_file);
+ output_diversion->u.file = m4_tmprename (diversion->divnum,
+ output_diversion->divnum);
+ output_diversion->used = 1;
+ output_file = output_diversion->u.file;
+ diversion->u.file = NULL;
+ diversion->size = 1;
+ }
else
- {
- if (!diversion->u.file)
- diversion->u.file = m4_tmpopen (diversion->divnum, true);
- insert_file (diversion->u.file);
- }
+ {
+ if (!diversion->u.file)
+ diversion->u.file = m4_tmpopen (diversion->divnum, true);
+ insert_file (diversion->u.file);
+ }
output_current_line = -1;
}
@@ -917,22 +918,22 @@ insert_diversion_helper (m4_diversion *diversion)
if (diversion->size)
{
if (!output_diversion)
- total_buffer_size -= diversion->size;
+ total_buffer_size -= diversion->size;
free (diversion->u.buffer);
diversion->size = 0;
}
else
{
if (diversion->u.file)
- {
- FILE *file = diversion->u.file;
- diversion->u.file = NULL;
- if (m4_tmpclose (file, diversion->divnum) != 0)
- m4_warn (errno, NULL,
- _("cannot clean temporary file for diversion"));
- }
+ {
+ FILE *file = diversion->u.file;
+ diversion->u.file = NULL;
+ if (m4_tmpclose (file, diversion->divnum) != 0)
+ m4_warn (errno, NULL,
+ _("cannot clean temporary file for diversion"));
+ }
if (m4_tmpremove (diversion->divnum) != 0)
- m4_warn (errno, NULL, _("cannot clean temporary file for diversion"));
+ m4_warn (errno, NULL, _("cannot clean temporary file for diversion"));
}
diversion->used = 0;
gl_oset_remove (diversion_table, diversion);
@@ -956,11 +957,11 @@ insert_diversion (int divnum)
if (divnum <= 0 || current_diversion == divnum)
return;
if (gl_oset_search_atleast (diversion_table, threshold_diversion_CB,
- &divnum, &elt))
+ &divnum, &elt))
{
m4_diversion *diversion = (m4_diversion *) elt;
if (diversion->divnum == divnum)
- insert_diversion_helper (diversion);
+ insert_diversion_helper (diversion);
}
}
@@ -978,7 +979,7 @@ undivert_all (void)
{
m4_diversion *diversion = (m4_diversion *) elt;
if (diversion->divnum != current_diversion)
- insert_diversion_helper (diversion);
+ insert_diversion_helper (diversion);
}
gl_oset_iterator_free (&iter);
}
@@ -1005,29 +1006,29 @@ freeze_diversions (FILE *file)
{
m4_diversion *diversion = (m4_diversion *) elt;
if (diversion->size || diversion->used)
- {
- if (diversion->size)
- xfprintf (file, "D%d,%d\n", diversion->divnum, diversion->used);
- else
- {
- struct stat file_stat;
- diversion->u.file = m4_tmpopen (diversion->divnum, true);
- if (fstat (fileno (diversion->u.file), &file_stat) < 0)
- m4_error (EXIT_FAILURE, errno, NULL,
- _("cannot stat diversion"));
- if (file_stat.st_size < 0
- || (file_stat.st_size + 0UL
- != (unsigned long int) file_stat.st_size))
- m4_error (EXIT_FAILURE, 0, NULL, _("diversion too large"));
- xfprintf (file, "%c%d,%lu\n", 'D', diversion->divnum,
- (unsigned long int) file_stat.st_size);
- }
-
- insert_diversion_helper (diversion);
- putc ('\n', file);
-
- last_inserted = diversion->divnum;
- }
+ {
+ if (diversion->size)
+ xfprintf (file, "D%d,%d\n", diversion->divnum, diversion->used);
+ else
+ {
+ struct stat file_stat;
+ diversion->u.file = m4_tmpopen (diversion->divnum, true);
+ if (fstat (fileno (diversion->u.file), &file_stat) < 0)
+ m4_error (EXIT_FAILURE, errno, NULL,
+ _("cannot stat diversion"));
+ if (file_stat.st_size < 0
+ || (file_stat.st_size + 0UL
+ != (unsigned long int) file_stat.st_size))
+ m4_error (EXIT_FAILURE, 0, NULL, _("diversion too large"));
+ xfprintf (file, "%c%d,%lu\n", 'D', diversion->divnum,
+ (unsigned long int) file_stat.st_size);
+ }
+
+ insert_diversion_helper (diversion);
+ putc ('\n', file);
+
+ last_inserted = diversion->divnum;
+ }
}
gl_oset_iterator_free (&iter);
diff --git a/src/path.c b/src/path.c
index 39aefaf..47b6387 100644
--- a/src/path.c
+++ b/src/path.c
@@ -67,7 +67,7 @@ include_env_init (void)
{
path_end = strchr (path, ':');
if (path_end)
- *path_end = '\0';
+ *path_end = '\0';
add_include_directory (path);
path = path_end + 1;
}
@@ -116,13 +116,13 @@ m4_fopen (const char *file)
struct stat st;
int fd = fileno (fp);
if (fstat (fd, &st) == 0 && S_ISDIR (st.st_mode))
- {
- fclose (fp);
- errno = EISDIR;
- return NULL;
- }
+ {
+ fclose (fp);
+ errno = EISDIR;
+ return NULL;
+ }
if (set_cloexec_flag (fd, true) != 0)
- m4_warn (errno, NULL, _("cannot protect input file across forks"));
+ m4_warn (errno, NULL, _("cannot protect input file across forks"));
}
return fp;
}
@@ -155,7 +155,7 @@ m4_path_search (const char *file, char **result)
if (fp != NULL)
{
if (result)
- *result = xstrdup (file);
+ *result = xstrdup (file);
return fp;
}
@@ -174,19 +174,19 @@ m4_path_search (const char *file, char **result)
fp = m4_fopen (name);
if (fp != NULL)
- {
- if (debug_level & DEBUG_TRACE_PATH)
- debug_message ("path search for %s found %s",
- quotearg_style (locale_quoting_style, file),
- quotearg_n_style (1, locale_quoting_style, name));
- if (set_cloexec_flag (fileno (fp), true) != 0)
- m4_warn (errno, NULL, _("cannot protect input file across forks"));
- if (result)
- *result = name;
- else
- free (name);
- return fp;
- }
+ {
+ if (debug_level & DEBUG_TRACE_PATH)
+ debug_message ("path search for %s found %s",
+ quotearg_style (locale_quoting_style, file),
+ quotearg_n_style (1, locale_quoting_style, name));
+ if (set_cloexec_flag (fileno (fp), true) != 0)
+ m4_warn (errno, NULL, _("cannot protect input file across forks"));
+ if (result)
+ *result = name;
+ else
+ free (name);
+ return fp;
+ }
free (name);
}
errno = e;
diff --git a/src/stackovf.c b/src/stackovf.c
index bcb5a00..a1a3f8a 100644
--- a/src/stackovf.c
+++ b/src/stackovf.c
@@ -37,7 +37,7 @@
1. The siginfo parameter (with siginfo.h, i.e., SVR4).
2. 4th "addr" parameter (assumed if struct sigcontext is defined,
- i.e., SunOS 4.x/BSD).
+ i.e., SunOS 4.x/BSD).
3. None (if no method is available). This case just prints a
message before aborting with a core dump. That way the user at
@@ -155,8 +155,8 @@ process_sigsegv (int signo, const char *p)
char buf[140];
snprintf (buf, sizeof buf,
- "process_sigsegv: p=%#lx stackend=%#lx diff=%ld bot=%#lx\n",
- (long) p, (long) stackend, (long) diff, (long) stackbot);
+ "process_sigsegv: p=%#lx stackend=%#lx diff=%ld bot=%#lx\n",
+ (long) p, (long) stackend, (long) diff, (long) stackbot);
write (2, buf, strlen (buf));
}
#endif
@@ -164,28 +164,28 @@ process_sigsegv (int signo, const char *p)
if (p != PARAM_NOSTACKOVF)
{
if (sbrk (8192) == (void *) -1)
- {
+ {
- /* sbrk failed. Assume the RLIMIT_VMEM prevents expansion even
- if the stack limit has not been reached. */
+ /* sbrk failed. Assume the RLIMIT_VMEM prevents expansion even
+ if the stack limit has not been reached. */
- ignore_value (write (2, "VMEM limit exceeded?\n", 21));
- p = PARAM_STACKOVF;
- }
+ ignore_value (write (2, "VMEM limit exceeded?\n", 21));
+ p = PARAM_STACKOVF;
+ }
if (diff >= -STACKOVF_DETECT && diff <= STACKOVF_DETECT)
- {
+ {
- /* The fault address is "sufficiently close" to the stack lim. */
+ /* The fault address is "sufficiently close" to the stack lim. */
- p = PARAM_STACKOVF;
- }
+ p = PARAM_STACKOVF;
+ }
if (p == PARAM_STACKOVF)
- {
+ {
- /* We have determined that this is indeed a stack overflow. */
+ /* We have determined that this is indeed a stack overflow. */
- (*stackovf_handler) (); /* should call exit() */
- }
+ (*stackovf_handler) (); /* should call exit() */
+ }
}
if (p == NULL)
{
@@ -215,7 +215,7 @@ sigsegv_handler (int signo, siginfo_t *ip, void *context
M4_GNUC_UNUSED)
{
process_sigsegv
(signo, (ip != NULL
- && ip->si_signo == SIGSEGV ? (char *) ip->si_addr : NULL));
+ && ip->si_signo == SIGSEGV ? (char *) ip->si_addr : NULL));
}
#elif HAVE_SIGINFO_T
@@ -227,7 +227,7 @@ sigsegv_handler (int signo, siginfo_t *ip)
{
process_sigsegv
(signo, (ip != NULL
- && ip->si_signo == SIGSEGV ? (char *) ip->si_addr : NULL));
+ && ip->si_signo == SIGSEGV ? (char *) ip->si_addr : NULL));
}
#elif HAVE_SIGCONTEXT
@@ -301,17 +301,17 @@ Error - Do not know how to set up stack-ovf trap
handler...
/* Grows toward increasing addresses. */
for (v = argv; (p = (char *) *v) != NULL; v++)
- {
- if (p < stackbot)
- stackbot = p;
- }
+ {
+ if (p < stackbot)
+ stackbot = p;
+ }
if ((char *) envp < stackbot)
- stackbot = (char *) envp;
+ stackbot = (char *) envp;
for (v = envp; (p = (char *) *v) != NULL; v++)
- {
- if (p < stackbot)
- stackbot = p;
- }
+ {
+ if (p < stackbot)
+ stackbot = p;
+ }
stackend = stackbot + stack_len;
}
else
@@ -320,17 +320,17 @@ Error - Do not know how to set up stack-ovf trap
handler...
/* The stack grows "downward" (toward decreasing addresses). */
for (v = argv; (p = (char *) *v) != NULL; v++)
- {
- if (p > stackbot)
- stackbot = p;
- }
+ {
+ if (p > stackbot)
+ stackbot = p;
+ }
if ((char *) envp > stackbot)
- stackbot = (char *) envp;
+ stackbot = (char *) envp;
for (v = envp; (p = (char *) *v) != NULL; v++)
- {
- if (p > stackbot)
- stackbot = p;
- }
+ {
+ if (p > stackbot)
+ stackbot = p;
+ }
stackend = stackbot - stack_len;
}
@@ -354,15 +354,15 @@ Error - Do not know how to set up stack-ovf trap
handler...
ss.ss_flags = 0;
if (sigaltstack (&ss, NULL) < 0)
{
- /* Oops - sigaltstack exists but doesn't work. We can't
- install the overflow detector, but should gracefully treat
- it as though sigaltstack doesn't exist. For example, this
- happens when compiled with Linux 2.1 headers but run
- against Linux 2.0 kernel. */
- free (ss.ss_sp);
- if (errno == ENOSYS)
- return;
- error (EXIT_FAILURE, errno, _("sigaltstack"));
+ /* Oops - sigaltstack exists but doesn't work. We can't
+ install the overflow detector, but should gracefully treat
+ it as though sigaltstack doesn't exist. For example, this
+ happens when compiled with Linux 2.1 headers but run
+ against Linux 2.0 kernel. */
+ free (ss.ss_sp);
+ if (errno == ENOSYS)
+ return;
+ error (EXIT_FAILURE, errno, _("sigaltstack"));
}
}
@@ -376,15 +376,15 @@ Error - Do not know how to set up stack-ovf trap
handler...
ss.ss_onstack = 0;
if (sigstack (&ss, NULL) < 0)
{
- /* Oops - sigstack exists but doesn't work. We can't install
- the overflow detector, but should gracefully treat it as
- though sigstack doesn't exist. For example, this happens
- when compiled with Linux 2.1 headers but run against Linux
- 2.0 kernel. */
- free (stackbuf);
- if (errno == ENOSYS)
- return;
- error (EXIT_FAILURE, errno, _("sigstack"));
+ /* Oops - sigstack exists but doesn't work. We can't install
+ the overflow detector, but should gracefully treat it as
+ though sigstack doesn't exist. For example, this happens
+ when compiled with Linux 2.1 headers but run against Linux
+ 2.0 kernel. */
+ free (stackbuf);
+ if (errno == ENOSYS)
+ return;
+ error (EXIT_FAILURE, errno, _("sigstack"));
}
}
diff --git a/src/symtab.c b/src/symtab.c
index dd9eb67..1e49fa5 100644
--- a/src/symtab.c
+++ b/src/symtab.c
@@ -64,13 +64,13 @@ show_profile (void)
for (i = 0; i < 5; i++)
{
xfprintf(f, "m4: lookup mode %d called %d times, %d compares, "
- "%d misses, %lld bytes\n",
- i, profiles[i].entry, profiles[i].comparisons,
- profiles[i].misses, profiles[i].bytes);
+ "%d misses, %lld bytes\n",
+ i, profiles[i].entry, profiles[i].comparisons,
+ profiles[i].misses, profiles[i].bytes);
}
xfprintf(f, "m4: %llu hash callbacks, %llu compare callbacks, "
- "%zu buckets, %u resizes\n",
- hash_entry, comparator_entry, current_size, resizes - 1);
+ "%zu buckets, %u resizes\n",
+ hash_entry, comparator_entry, current_size, resizes - 1);
fclose (f);
}
@@ -147,8 +147,8 @@ symtab_comparator (const void *entry_a, const void *entry_b)
const symbol *sym_a = (const symbol *) entry_a;
const symbol *sym_b = (const symbol *) entry_b;
return (SYMBOL_NAME_LEN (sym_a) == SYMBOL_NAME_LEN (sym_b)
- && memcmp (SYMBOL_NAME (sym_a), SYMBOL_NAME (sym_b),
- SYMBOL_NAME_LEN (sym_a)) == 0);
+ && memcmp (SYMBOL_NAME (sym_a), SYMBOL_NAME (sym_b),
+ SYMBOL_NAME_LEN (sym_a)) == 0);
}
/*---------------------------.
@@ -177,7 +177,7 @@ void
symtab_init (size_t size)
{
symtab = hash_initialize (size, NULL, symtab_hasher, symtab_comparator,
- symtab_free_entry);
+ symtab_free_entry);
if (!symtab)
xalloc_die ();
@@ -208,7 +208,7 @@ free_symbol (symbol *sym)
{
free (SYMBOL_NAME (sym));
if (SYMBOL_TYPE (sym) == TOKEN_TEXT)
- free (SYMBOL_TEXT (sym));
+ free (SYMBOL_TEXT (sym));
free (sym);
}
}
@@ -252,58 +252,58 @@ lookup_symbol (const char *name, size_t len,
symbol_lookup mode)
case SYMBOL_INSERT:
/* If the name was found in the table, check whether it is still in
- use by a pending expansion. If so, replace the table element with
- a new one; if not, just return the symbol. If not found, just
- insert the name, and return the new symbol. */
+ use by a pending expansion. If so, replace the table element with
+ a new one; if not, just return the symbol. If not found, just
+ insert the name, and return the new symbol. */
if (entry)
- {
- sym = entry->stack;
- if (SYMBOL_PENDING_EXPANSIONS (sym) > 0)
- {
- symbol *old = sym;
- SYMBOL_DELETED (old) = true;
-
- sym = (symbol *) xmalloc (sizeof *sym);
- SYMBOL_TYPE (sym) = TOKEN_VOID;
- SYMBOL_TRACED (sym) = SYMBOL_TRACED (old);
- SYMBOL_NAME (sym) = xmemdup0 (name, len);
- SYMBOL_NAME_LEN (sym) = len;
- SYMBOL_MACRO_ARGS (sym) = false;
- SYMBOL_BLIND_NO_ARGS (sym) = false;
- SYMBOL_DELETED (sym) = false;
- SYMBOL_PENDING_EXPANSIONS (sym) = 0;
-
- if (old == entry)
- {
- old = (symbol *) hash_delete (symtab, entry);
- assert (entry == old);
- sym->stack = sym;
- entry = (symbol *) hash_insert (symtab, sym);
- if (entry)
- assert (sym == entry);
- else
- xalloc_die ();
- }
- else
- {
- entry->stack = sym;
- sym->stack = old->stack;
- }
- old->stack = NULL;
- }
- return sym;
- }
+ {
+ sym = entry->stack;
+ if (SYMBOL_PENDING_EXPANSIONS (sym) > 0)
+ {
+ symbol *old = sym;
+ SYMBOL_DELETED (old) = true;
+
+ sym = (symbol *) xmalloc (sizeof *sym);
+ SYMBOL_TYPE (sym) = TOKEN_VOID;
+ SYMBOL_TRACED (sym) = SYMBOL_TRACED (old);
+ SYMBOL_NAME (sym) = xmemdup0 (name, len);
+ SYMBOL_NAME_LEN (sym) = len;
+ SYMBOL_MACRO_ARGS (sym) = false;
+ SYMBOL_BLIND_NO_ARGS (sym) = false;
+ SYMBOL_DELETED (sym) = false;
+ SYMBOL_PENDING_EXPANSIONS (sym) = 0;
+
+ if (old == entry)
+ {
+ old = (symbol *) hash_delete (symtab, entry);
+ assert (entry == old);
+ sym->stack = sym;
+ entry = (symbol *) hash_insert (symtab, sym);
+ if (entry)
+ assert (sym == entry);
+ else
+ xalloc_die ();
+ }
+ else
+ {
+ entry->stack = sym;
+ sym->stack = old->stack;
+ }
+ old->stack = NULL;
+ }
+ return sym;
+ }
/* Fall through. */
case SYMBOL_PUSHDEF:
/* Insert a name in the symbol table. If there is already a
- symbol with the name, add it to the pushdef stack. Since the
- hash table does not allow the insertion of duplicates, the
- pushdef stack is a circular chain; the hash entry is the
- oldest entry, which points to the newest entry; all other
- entries point to the next older entry. */
+ symbol with the name, add it to the pushdef stack. Since the
+ hash table does not allow the insertion of duplicates, the
+ pushdef stack is a circular chain; the hash entry is the
+ oldest entry, which points to the newest entry; all other
+ entries point to the next older entry. */
sym = (symbol *) xmalloc (sizeof *sym);
SYMBOL_TYPE (sym) = TOKEN_VOID;
SYMBOL_TRACED (sym) = false;
@@ -315,82 +315,82 @@ lookup_symbol (const char *name, size_t len,
symbol_lookup mode)
SYMBOL_PENDING_EXPANSIONS (sym) = 0;
if (entry)
- {
- assert (mode == SYMBOL_PUSHDEF);
- sym->stack = entry->stack;
- entry->stack = sym;
- SYMBOL_TRACED (sym) = SYMBOL_TRACED (sym->stack);
- }
+ {
+ assert (mode == SYMBOL_PUSHDEF);
+ sym->stack = entry->stack;
+ entry->stack = sym;
+ SYMBOL_TRACED (sym) = SYMBOL_TRACED (sym->stack);
+ }
else
- {
- sym->stack = sym;
- entry = (symbol *) hash_insert (symtab, sym);
- if (entry)
- assert (sym == entry);
- else
- xalloc_die ();
- }
+ {
+ sym->stack = sym;
+ entry = (symbol *) hash_insert (symtab, sym);
+ if (entry)
+ assert (sym == entry);
+ else
+ xalloc_die ();
+ }
return sym;
case SYMBOL_DELETE:
case SYMBOL_POPDEF:
/* Delete occurrences of symbols with NAME. SYMBOL_DELETE kills
- all definitions, SYMBOL_POPDEF kills only the first.
- However, if the last instance of a symbol is marked for
- tracing, reinsert a placeholder in the table. And if the
- definition is still in use, let the caller free the memory
- after it is done with the symbol. */
+ all definitions, SYMBOL_POPDEF kills only the first.
+ However, if the last instance of a symbol is marked for
+ tracing, reinsert a placeholder in the table. And if the
+ definition is still in use, let the caller free the memory
+ after it is done with the symbol. */
if (!entry
- || (SYMBOL_TYPE (entry) == TOKEN_VOID && entry->stack == entry
- && SYMBOL_TRACED (entry)))
- return NULL;
+ || (SYMBOL_TYPE (entry) == TOKEN_VOID && entry->stack == entry
+ && SYMBOL_TRACED (entry)))
+ return NULL;
{
- bool traced = false;
- symbol *result = sym = entry->stack;
- if (sym != entry && mode == SYMBOL_POPDEF)
- {
- SYMBOL_TRACED (sym->stack) = SYMBOL_TRACED (sym);
- entry->stack = sym->stack;
- sym->stack = NULL;
- free_symbol (sym);
- }
- else
- {
- traced = SYMBOL_TRACED (sym);
- while (sym != entry)
- {
- symbol *old = sym;
- sym = sym->stack;
- old->stack = NULL;
- free_symbol (old);
- }
- sym = (symbol *) hash_delete (symtab, entry);
- assert (sym == entry);
- sym->stack = NULL;
- free_symbol (sym);
- }
- if (traced)
- {
- sym = (symbol *) xmalloc (sizeof *sym);
- SYMBOL_TYPE (sym) = TOKEN_VOID;
- SYMBOL_TRACED (sym) = true;
- SYMBOL_NAME (sym) = xmemdup0 (name, len);
- SYMBOL_NAME_LEN (sym) = len;
- SYMBOL_MACRO_ARGS (sym) = false;
- SYMBOL_BLIND_NO_ARGS (sym) = false;
- SYMBOL_DELETED (sym) = false;
- SYMBOL_PENDING_EXPANSIONS (sym) = 0;
-
- sym->stack = sym;
- entry = (symbol *) hash_insert (symtab, sym);
- if (entry)
- assert (sym == entry);
- else
- xalloc_die ();
- }
- return result;
+ bool traced = false;
+ symbol *result = sym = entry->stack;
+ if (sym != entry && mode == SYMBOL_POPDEF)
+ {
+ SYMBOL_TRACED (sym->stack) = SYMBOL_TRACED (sym);
+ entry->stack = sym->stack;
+ sym->stack = NULL;
+ free_symbol (sym);
+ }
+ else
+ {
+ traced = SYMBOL_TRACED (sym);
+ while (sym != entry)
+ {
+ symbol *old = sym;
+ sym = sym->stack;
+ old->stack = NULL;
+ free_symbol (old);
+ }
+ sym = (symbol *) hash_delete (symtab, entry);
+ assert (sym == entry);
+ sym->stack = NULL;
+ free_symbol (sym);
+ }
+ if (traced)
+ {
+ sym = (symbol *) xmalloc (sizeof *sym);
+ SYMBOL_TYPE (sym) = TOKEN_VOID;
+ SYMBOL_TRACED (sym) = true;
+ SYMBOL_NAME (sym) = xmemdup0 (name, len);
+ SYMBOL_NAME_LEN (sym) = len;
+ SYMBOL_MACRO_ARGS (sym) = false;
+ SYMBOL_BLIND_NO_ARGS (sym) = false;
+ SYMBOL_DELETED (sym) = false;
+ SYMBOL_PENDING_EXPANSIONS (sym) = 0;
+
+ sym->stack = sym;
+ entry = (symbol *) hash_insert (symtab, sym);
+ if (entry)
+ assert (sym == entry);
+ else
+ xalloc_die ();
+ }
+ return result;
}
default:
@@ -419,8 +419,8 @@ hack_all_symbols (hack_symbol *func, void *data)
while (sym)
{
/* We allow func to call SYMBOL_POPDEF, which can invalidate
- sym, so we must grab the next element to traverse before
- calling func. */
+ sym, so we must grab the next element to traverse before
+ calling func. */
next = (symbol *) hash_get_next (symtab, sym);
func (sym->stack, data);
sym = next;
@@ -447,23 +447,23 @@ symtab_debug (void)
text = TOKEN_DATA_TEXT (&td);
len = TOKEN_DATA_LEN (&td);
if (*text == '_')
- {
- delete = 1;
- text++;
- len--;
- }
+ {
+ delete = 1;
+ text++;
+ len--;
+ }
else
- delete = 0;
+ delete = 0;
s = lookup_symbol (text, len, SYMBOL_LOOKUP);
if (s == NULL)
- xprintf ("Name `%s' is unknown\n", text);
+ xprintf ("Name `%s' is unknown\n", text);
if (delete)
- lookup_symbol (text, len, SYMBOL_DELETE);
+ lookup_symbol (text, len, SYMBOL_DELETE);
else
- lookup_symbol (text, len, SYMBOL_INSERT);
+ lookup_symbol (text, len, SYMBOL_INSERT);
}
symtab_print_list (i++);
}
@@ -479,15 +479,15 @@ symtab_print_list (int i)
{
stack = sym->stack;
do
- {
- xprintf ("\tname %s, len %zu, addr %p, "
- "stack %p, flags%s%s, pending %d\n",
- SYMBOL_NAME (stack), SYMBOL_NAME_LEN (stack),
- stack, stack->stack, SYMBOL_TRACED (stack) ? " traced" : "",
- SYMBOL_DELETED (stack) ? " deleted" : "",
- SYMBOL_PENDING_EXPANSIONS (stack));
- stack = stack->stack;
- }
+ {
+ xprintf ("\tname %s, len %zu, addr %p, "
+ "stack %p, flags%s%s, pending %d\n",
+ SYMBOL_NAME (stack), SYMBOL_NAME_LEN (stack),
+ stack, stack->stack, SYMBOL_TRACED (stack) ? " traced" : "",
+ SYMBOL_DELETED (stack) ? " deleted" : "",
+ SYMBOL_PENDING_EXPANSIONS (stack));
+ stack = stack->stack;
+ }
while (stack != sym);
sym = (symbol *) hash_get_next (symtab, sym);
}
hooks/post-receive
--
GNU M4 source repository
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [SCM] GNU M4 source repository branch, branch-1.6, updated. v1.5.89a-148-gda026e3,
Eric Blake <=