[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[SCM] GNU M4 source repository branch, branch-1.4, updated. v1.4.13-26-g
|
From: |
Eric Blake |
|
Subject: |
[SCM] GNU M4 source repository branch, branch-1.4, updated. v1.4.13-26-ga8cef71 |
|
Date: |
Tue, 29 Dec 2009 14:26:26 +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=a8cef71593e876b027733fdb0137ed1655cae584
The branch, branch-1.4 has been updated
via a8cef71593e876b027733fdb0137ed1655cae584 (commit)
via 180b7d19bf95d2abb21bca587a0684eca69679ad (commit)
via 43b9828d5bfe5c9be902ad86053e59f3a5ab2dd4 (commit)
from a6c565c6f4b934be334dd9ada97b215595d10103 (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 a8cef71593e876b027733fdb0137ed1655cae584
Author: Eric Blake <address@hidden>
Date: Thu Dec 10 17:20:30 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>
commit 180b7d19bf95d2abb21bca587a0684eca69679ad
Author: Eric Blake <address@hidden>
Date: Thu Dec 10 16:56:09 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.
* checks/stackovf.test: 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/symtab.c: Likewise.
Signed-off-by: Eric Blake <address@hidden>
commit 43b9828d5bfe5c9be902ad86053e59f3a5ab2dd4
Author: Eric Blake <address@hidden>
Date: Mon Dec 14 12:09:44 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.
* build-aux/.cvsignore: Regenerate.
* build-aux/.gitignore: Likewise.
Signed-off-by: Eric Blake <address@hidden>
-----------------------------------------------------------------------
Summary of changes:
.gitmodules | 4 +-
.x-sc_prohibit_tab_based_indentation | 5 +
ChangeLog | 39 ++
HACKING | 32 ++-
Makefile.am | 7 +-
TODO | 28 +-
bootstrap | 26 +-
build-aux/.cvsignore | 4 +-
build-aux/.gitignore | 4 +-
c-boxes.el | 440 +++++++++---------
cfg.mk | 6 +
checks/check-them | 12 +-
checks/get-them | 20 +-
checks/stackovf.test | 12 +-
configure.ac | 18 +-
gnulib | 2 +-
m4/gnulib-cache.m4 | 3 +-
src/builtin.c | 822 +++++++++++++++++-----------------
src/debug.c | 252 ++++++------
src/eval.c | 488 ++++++++++----------
src/format.c | 338 +++++++-------
src/freeze.c | 268 ++++++------
src/input.c | 462 ++++++++++----------
src/m4.c | 306 +++++++-------
src/m4.h | 44 +-
src/macro.c | 170 ++++----
src/output.c | 493 ++++++++++----------
src/path.c | 36 +-
src/symtab.c | 196 ++++----
29 files changed, 2312 insertions(+), 2225 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 0c9b193..ba96302 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,42 @@
+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.
+ * checks/stackovf.test: 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/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.
+ * build-aux/.cvsignore: Regenerate.
+ * build-aux/.gitignore: Likewise.
+
2009-11-28 Eric Blake <address@hidden>
Work around BSD getopt bug.
diff --git a/HACKING b/HACKING
index 8f5088f..2d28787 100644
--- a/HACKING
+++ b/HACKING
@@ -188,8 +188,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
@@ -201,8 +227,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 d10dfaa..134f4c3 100644
--- a/TODO
+++ b/TODO
@@ -5,32 +5,32 @@ of these ideas, listed more or less in decreasing order of
priority.
* Features or problems
- Fix format() builtin to handle %c more like printf(1) in the shell
- http://lists.gnu.org/archive/html/bug-m4/2007-05/msg00047.html
+ http://lists.gnu.org/archive/html/bug-m4/2007-05/msg00047.html
Also, gnulib needs help to overcome mingw bugs related to format().
- 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 e9c8200..56c2ed1 100755
--- a/bootstrap
+++ b/bootstrap
@@ -1,6 +1,6 @@
#! /bin/sh
-# bootstrap (GNU M4) version 2009-03-23
+# 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
}
@@ -268,11 +268,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/build-aux/.cvsignore b/build-aux/.cvsignore
index 16ef012..8114aea 100644
--- a/build-aux/.cvsignore
+++ b/build-aux/.cvsignore
@@ -1,4 +1,5 @@
announce-gen
+arg-nonnull.h
config.rpath
gendocs.sh
git-version-gen
@@ -6,5 +7,6 @@ gnu-web-doc-update
gnupload
link-warning.h
update-copyright
-vc-list-files
useless-if-before-free
+vc-list-files
+warn-on-use.h
diff --git a/build-aux/.gitignore b/build-aux/.gitignore
index e7a0cfc..cf7ea23 100644
--- a/build-aux/.gitignore
+++ b/build-aux/.gitignore
@@ -1,4 +1,5 @@
/announce-gen
+/arg-nonnull.h
/config.rpath
/gendocs.sh
/git-version-gen
@@ -6,5 +7,6 @@
/gnupload
/link-warning.h
/update-copyright
-/vc-list-files
/useless-if-before-free
+/vc-list-files
+/warn-on-use.h
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 00a9e56..10fdcc5 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -33,3 +33,9 @@ config_h_header = "m4\.h"
# Hash of NEWS contents, to ensure we don't add entries to wrong section.
old_NEWS_hash = 0330971054cd4fb4e94b85fe367980f2
+
+# 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 42ca8a3..58ab9d1 100755
--- a/checks/check-them
+++ b/checks/check-them
@@ -94,9 +94,9 @@ do
*stackovf.test)
"$file" "$m4"
case $? in
- 77) skipped="$skipped $file";;
- 0) ;;
- *) failed="$failed $file"
+ 77) skipped="$skipped $file";;
+ 0) ;;
+ *) failed="$failed $file"
esac
continue ;;
esac
@@ -135,11 +135,11 @@ do
cp $err $xerr ;;
'')
${SED} '/^dnl @error{}/!d
- s///; '"s|^m4:|$m4name:|; s|examples/|$examples/|" \
- "$file" > $xerr ;;
+ s///; '"s|^m4:|$m4name:|; s|examples/|$examples/|" \
+ "$file" > $xerr ;;
*)
${SED} "s|^m4:|$m4name:|; s|examples/|$examples/|" \
- "$examples/$xerrfile" > $xerr ;;
+ "$examples/$xerrfile" > $xerr ;;
esac
# For the benefit of mingw, normalize \r\n line endings
diff --git a/checks/get-them b/checks/get-them
index 50735d3..de1c506 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/checks/stackovf.test b/checks/stackovf.test
index 47d0841..baf0414 100755
--- a/checks/stackovf.test
+++ b/checks/stackovf.test
@@ -83,14 +83,14 @@ else
case `cat "$tmpfile"` in
*stack\ overflow*)
case `echo "$tmpdir"/*` in
- $tmpfile)
- echo "Pass"
- exitcode=0 ;;
- *) echo "Failure - $m4 created unexpected core dump"
- ls -l "$tmpdir" ;;
+ $tmpfile)
+ echo "Pass"
+ exitcode=0 ;;
+ *) echo "Failure - $m4 created unexpected core dump"
+ ls -l "$tmpdir" ;;
esac ;;
*) echo "Failure - $m4 aborted unexpectedly";
- ;;
+ ;;
esac
fi
diff --git a/configure.ac b/configure.ac
index 8697c8c..a917a65 100644
--- a/configure.ac
+++ b/configure.ac
@@ -145,15 +145,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
@@ -167,12 +167,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/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 2440df0..c81e67f 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 --avoid=lock-tests --avoid=tls-tests
--makefile-name=gnulib.mk --no-libtool --macro-prefix=M4 announce-gen assert
autobuild avltree-oset binary-io c-stack clean-temp cloexec close-stream
closein config-h dirname error execute fdl-1.3 fflush filenamecat fopen
fopen-safer fseeko gendocs getopt-gnu git-version-gen gnu-web-doc-update
gnumakefile gnupload gpl-3.0 ignore-value intprops maintainer-makefile
manywarnings memchr2 mkstemp obstack pipe progname regex sigaction stdbool
stdint stdlib-safer strsignal strstr strtod strtol unlocked-io update-copyright
vc-list-files verror version-etc version-etc-fsf wait-process xalloc 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 --avoid=lock-tests --avoid=tls-tests
--makefile-name=gnulib.mk --no-libtool --macro-prefix=M4 announce-gen assert
autobuild avltree-oset binary-io c-stack clean-temp cloexec close-stream
closein config-h dirname error execute fdl-1.3 fflush filenamecat fopen
fopen-safer fseeko gendocs getopt-gnu git-version-gen gnu-web-doc-update
gnumakefile gnupload gpl-3.0 ignore-value intprops maintainer-makefile
manywarnings memchr2 mkstemp obstack pipe progname regex sigaction stdbool
stdint stdlib-safer strsignal strstr strtod strtol unlocked-io update-copyright
vc-list-files verror version-etc version-etc-fsf wait-process xalloc xoset
xprintf xvasprintf-posix
# Specification in the form of a few gnulib-tool.m4 macro invocations:
gl_LOCAL_DIR([local])
@@ -73,6 +73,7 @@ gl_MODULES([
version-etc-fsf
wait-process
xalloc
+ xoset
xprintf
xvasprintf-posix
])
diff --git a/src/builtin.c b/src/builtin.c
index 3dcca8a..da90e1d 100644
--- a/src/builtin.c
+++ b/src/builtin.c
@@ -263,12 +263,12 @@ set_macro_sequence (const char *regexp)
if (msg != NULL)
{
M4ERROR ((EXIT_FAILURE, 0,
- "--warn-macro-sequence: bad regular expression `%s': %s",
- regexp, msg));
+ "--warn-macro-sequence: bad regular expression `%s': %s",
+ 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;
}
@@ -308,27 +308,27 @@ define_user_macro (const char *name, const char *text,
symbol_lookup mode)
size_t len = strlen (defn);
while ((offset = re_search (¯o_sequence_buf, defn, len, offset,
- len - offset, ¯o_sequence_regs)) >= 0)
- {
- /* Skip empty matches. */
- if (macro_sequence_regs.start[0] == macro_sequence_regs.end[0])
- offset++;
- else
- {
- char tmp;
- offset = macro_sequence_regs.end[0];
- tmp = defn[offset];
- defn[offset] = '\0';
- M4ERROR ((warning_status, 0,
- "Warning: definition of `%s' contains sequence `%s'",
- name, defn + macro_sequence_regs.start[0]));
- defn[offset] = tmp;
- }
- }
+ len - offset, ¯o_sequence_regs)) >= 0)
+ {
+ /* Skip empty matches. */
+ if (macro_sequence_regs.start[0] == macro_sequence_regs.end[0])
+ offset++;
+ else
+ {
+ char tmp;
+ offset = macro_sequence_regs.end[0];
+ tmp = defn[offset];
+ defn[offset] = '\0';
+ M4ERROR ((warning_status, 0,
+ "Warning: definition of `%s' contains sequence `%s'",
+ name, defn + macro_sequence_regs.start[0]));
+ defn[offset] = tmp;
+ }
+ }
if (offset == -2)
- M4ERROR ((warning_status, 0,
- "error checking --warn-macro-sequence for macro `%s'",
- name));
+ M4ERROR ((warning_status, 0,
+ "error checking --warn-macro-sequence for macro `%s'",
+ name));
}
}
@@ -346,28 +346,28 @@ builtin_init (void)
for (bp = &builtin_tab[0]; bp->name != NULL; bp++)
if (!no_gnu_extensions || !bp->gnu_extension)
{
- if (prefix_all_builtins)
- {
- string = (char *) xmalloc (strlen (bp->name) + 4);
- strcpy (string, "m4_");
- strcat (string, bp->name);
- define_builtin (string, bp, SYMBOL_INSERT);
- free (string);
- }
- else
- define_builtin (bp->name, bp, SYMBOL_INSERT);
+ if (prefix_all_builtins)
+ {
+ string = (char *) xmalloc (strlen (bp->name) + 4);
+ strcpy (string, "m4_");
+ strcat (string, bp->name);
+ define_builtin (string, bp, SYMBOL_INSERT);
+ free (string);
+ }
+ else
+ define_builtin (bp->name, 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, pp->func, SYMBOL_INSERT);
+ if (pp->unix_name != NULL)
+ define_user_macro (pp->unix_name, pp->func, SYMBOL_INSERT);
}
else
{
- if (pp->gnu_name != NULL)
- define_user_macro (pp->gnu_name, pp->func, SYMBOL_INSERT);
+ if (pp->gnu_name != NULL)
+ define_user_macro (pp->gnu_name, pp->func, SYMBOL_INSERT);
}
}
@@ -387,15 +387,15 @@ bad_argc (token_data *name, int argc, int min, int max)
if (min > 0 && argc < min)
{
if (!suppress_warnings)
- M4ERROR ((warning_status, 0,
- "Warning: too few arguments to builtin `%s'",
- TOKEN_DATA_TEXT (name)));
+ M4ERROR ((warning_status, 0,
+ "Warning: too few arguments to builtin `%s'",
+ TOKEN_DATA_TEXT (name)));
isbad = true;
}
else if (max > 0 && argc > max && !suppress_warnings)
M4ERROR ((warning_status, 0,
- "Warning: excess arguments to builtin `%s' ignored",
- TOKEN_DATA_TEXT (name)));
+ "Warning: excess arguments to builtin `%s' ignored",
+ TOKEN_DATA_TEXT (name)));
return isbad;
}
@@ -415,28 +415,28 @@ numeric_arg (token_data *macro, const char *arg, int
*valuep)
{
*valuep = 0;
M4ERROR ((warning_status, 0,
- "empty string treated as 0 in builtin `%s'",
- TOKEN_DATA_TEXT (macro)));
+ "empty string treated as 0 in builtin `%s'",
+ TOKEN_DATA_TEXT (macro)));
}
else
{
errno = 0;
*valuep = strtol (arg, &endp, 10);
if (*endp != '\0')
- {
- M4ERROR ((warning_status, 0,
- "non-numeric argument to builtin `%s'",
- TOKEN_DATA_TEXT (macro)));
- return false;
- }
+ {
+ M4ERROR ((warning_status, 0,
+ "non-numeric argument to builtin `%s'",
+ TOKEN_DATA_TEXT (macro)));
+ return false;
+ }
if (isspace (to_uchar (*arg)))
- M4ERROR ((warning_status, 0,
- "leading whitespace ignored in builtin `%s'",
- TOKEN_DATA_TEXT (macro)));
+ M4ERROR ((warning_status, 0,
+ "leading whitespace ignored in builtin `%s'",
+ TOKEN_DATA_TEXT (macro)));
else if (errno == ERANGE)
- M4ERROR ((warning_status, 0,
- "numeric overflow detected in builtin `%s'",
- TOKEN_DATA_TEXT (macro)));
+ M4ERROR ((warning_status, 0,
+ "numeric overflow detected in builtin `%s'",
+ TOKEN_DATA_TEXT (macro)));
}
return true;
}
@@ -503,7 +503,7 @@ shipout_int (struct obstack *obs, int val)
static void
dump_args (struct obstack *obs, int argc, token_data **argv,
- const char *sep, bool quoted)
+ const char *sep, bool quoted)
{
int i;
size_t len = strlen (sep);
@@ -511,20 +511,20 @@ dump_args (struct obstack *obs, int argc, token_data
**argv,
for (i = 1; i < argc; i++)
{
if (i > 1)
- obstack_grow (obs, sep, len);
+ obstack_grow (obs, sep, len);
if (quoted)
- obstack_grow (obs, lquote.string, lquote.length);
+ obstack_grow (obs, lquote.string, lquote.length);
obstack_grow (obs, TOKEN_DATA_TEXT (argv[i]),
- strlen (TOKEN_DATA_TEXT (argv[i])));
+ strlen (TOKEN_DATA_TEXT (argv[i])));
if (quoted)
- obstack_grow (obs, rquote.string, rquote.length);
+ obstack_grow (obs, rquote.string, rquote.length);
}
}
/* The rest of this file is code for builtins and expansion of user
defined macros. All the functions for builtins have a prototype as:
- void m4_MACRONAME (struct obstack *obs, int argc, char *argv[]);
+ void m4_MACRONAME (struct obstack *obs, int argc, char *argv[]);
The function are expected to leave their expansion on the obstack OBS,
as an unfinished object. ARGV is a table of ARGC pointers to the
@@ -552,7 +552,7 @@ define_macro (int argc, token_data **argv, symbol_lookup
mode)
if (TOKEN_DATA_TYPE (argv[1]) != TOKEN_TEXT)
{
M4ERROR ((warning_status, 0,
- "Warning: %s: invalid macro name ignored", ARG (0)));
+ "Warning: %s: invalid macro name ignored", ARG (0)));
return;
}
@@ -571,15 +571,15 @@ define_macro (int argc, token_data **argv, symbol_lookup
mode)
case TOKEN_FUNC:
bp = find_builtin_by_addr (TOKEN_DATA_FUNC (argv[2]));
if (bp == NULL)
- return;
+ return;
else
- define_builtin (ARG (1), bp, mode);
+ define_builtin (ARG (1), bp, mode);
break;
case TOKEN_VOID:
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad token data type in define_macro ()"));
+ "INTERNAL ERROR: bad token data type in define_macro ()"));
abort ();
}
}
@@ -667,19 +667,19 @@ m4_ifelse (struct obstack *obs, int argc, token_data
**argv)
else
switch (argc)
- {
- case 3:
- return;
+ {
+ case 3:
+ return;
- case 4:
- case 5:
- result = ARG (3);
- break;
+ case 4:
+ case 5:
+ result = ARG (3);
+ break;
- default:
- argc -= 3;
- argv += 3;
- }
+ default:
+ argc -= 3;
+ argv += 3;
+ }
obstack_grow (obs, result, strlen (result));
}
@@ -719,7 +719,7 @@ static int
dumpdef_cmp (const void *s1, const void *s2)
{
return strcmp (SYMBOL_NAME (* (symbol *const *) s1),
- SYMBOL_NAME (* (symbol *const *) s2));
+ SYMBOL_NAME (* (symbol *const *) s2));
}
/*-------------------------------------------------------------------------.
@@ -746,14 +746,14 @@ m4_dumpdef (struct obstack *obs, int argc, token_data
**argv)
else
{
for (i = 1; i < argc; i++)
- {
- s = lookup_symbol (TOKEN_DATA_TEXT (argv[i]), SYMBOL_LOOKUP);
- if (s != NULL && SYMBOL_TYPE (s) != TOKEN_VOID)
- dump_symbol (s, &data);
- else
- M4ERROR ((warning_status, 0,
- "undefined macro `%s'", TOKEN_DATA_TEXT (argv[i])));
- }
+ {
+ s = lookup_symbol (TOKEN_DATA_TEXT (argv[i]), SYMBOL_LOOKUP);
+ if (s != NULL && SYMBOL_TYPE (s) != TOKEN_VOID)
+ dump_symbol (s, &data);
+ else
+ M4ERROR ((warning_status, 0,
+ "undefined macro `%s'", TOKEN_DATA_TEXT (argv[i])));
+ }
}
/* Make table of symbols invisible to expand_macro (). */
@@ -767,33 +767,33 @@ m4_dumpdef (struct obstack *obs, int argc, token_data
**argv)
DEBUG_PRINT1 ("%s:\t", SYMBOL_NAME (data.base[0]));
switch (SYMBOL_TYPE (data.base[0]))
- {
- case TOKEN_TEXT:
- if (debug_level & DEBUG_TRACE_QUOTE)
- DEBUG_PRINT3 ("%s%s%s\n",
- lquote.string, SYMBOL_TEXT (data.base[0]),
rquote.string);
- else
- DEBUG_PRINT1 ("%s\n", SYMBOL_TEXT (data.base[0]));
- break;
-
- case TOKEN_FUNC:
- bp = find_builtin_by_addr (SYMBOL_FUNC (data.base[0]));
- if (bp == NULL)
- {
- M4ERROR ((warning_status, 0, "\
+ {
+ case TOKEN_TEXT:
+ if (debug_level & DEBUG_TRACE_QUOTE)
+ DEBUG_PRINT3 ("%s%s%s\n",
+ lquote.string, SYMBOL_TEXT (data.base[0]),
rquote.string);
+ else
+ DEBUG_PRINT1 ("%s\n", SYMBOL_TEXT (data.base[0]));
+ break;
+
+ case TOKEN_FUNC:
+ bp = find_builtin_by_addr (SYMBOL_FUNC (data.base[0]));
+ if (bp == NULL)
+ {
+ M4ERROR ((warning_status, 0, "\
INTERNAL ERROR: builtin not found in builtin table"));
- abort ();
- }
- DEBUG_PRINT1 ("<%s>\n", bp->name);
- break;
-
- case TOKEN_VOID:
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad token data type in m4_dumpdef ()"));
- abort ();
- break;
- }
+ abort ();
+ }
+ DEBUG_PRINT1 ("<%s>\n", bp->name);
+ break;
+
+ case TOKEN_VOID:
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad token data type in m4_dumpdef ()"));
+ abort ();
+ break;
+ }
}
}
@@ -815,7 +815,7 @@ m4_builtin (struct obstack *obs, int argc, token_data
**argv)
if (TOKEN_DATA_TYPE (argv[1]) != TOKEN_TEXT)
{
M4ERROR ((warning_status, 0,
- "Warning: %s: invalid macro name ignored", ARG (0)));
+ "Warning: %s: invalid macro name ignored", ARG (0)));
return;
}
@@ -823,17 +823,17 @@ m4_builtin (struct obstack *obs, int argc, token_data
**argv)
bp = find_builtin_by_name (name);
if (bp->func == m4_placeholder)
M4ERROR ((warning_status, 0,
- "undefined builtin `%s'", name));
+ "undefined builtin `%s'", name));
else
{
int i;
if (! bp->groks_macro_args)
- for (i = 2; i < argc; i++)
- if (TOKEN_DATA_TYPE (argv[i]) != TOKEN_TEXT)
- {
- TOKEN_DATA_TYPE (argv[i]) = TOKEN_TEXT;
- TOKEN_DATA_TEXT (argv[i]) = (char *) "";
- }
+ for (i = 2; i < argc; i++)
+ if (TOKEN_DATA_TYPE (argv[i]) != TOKEN_TEXT)
+ {
+ TOKEN_DATA_TYPE (argv[i]) = TOKEN_TEXT;
+ TOKEN_DATA_TEXT (argv[i]) = (char *) "";
+ }
bp->func (obs, argc - 1, argv + 1);
}
}
@@ -856,7 +856,7 @@ m4_indir (struct obstack *obs, int argc, token_data **argv)
if (TOKEN_DATA_TYPE (argv[1]) != TOKEN_TEXT)
{
M4ERROR ((warning_status, 0,
- "Warning: %s: invalid macro name ignored", ARG (0)));
+ "Warning: %s: invalid macro name ignored", ARG (0)));
return;
}
@@ -864,17 +864,17 @@ m4_indir (struct obstack *obs, int argc, token_data
**argv)
s = lookup_symbol (name, SYMBOL_LOOKUP);
if (s == NULL || SYMBOL_TYPE (s) == TOKEN_VOID)
M4ERROR ((warning_status, 0,
- "undefined macro `%s'", name));
+ "undefined macro `%s'", name));
else
{
int i;
if (! SYMBOL_MACRO_ARGS (s))
- for (i = 2; i < argc; i++)
- if (TOKEN_DATA_TYPE (argv[i]) != TOKEN_TEXT)
- {
- TOKEN_DATA_TYPE (argv[i]) = TOKEN_TEXT;
- TOKEN_DATA_TEXT (argv[i]) = (char *) "";
- }
+ for (i = 2; i < argc; i++)
+ if (TOKEN_DATA_TYPE (argv[i]) != TOKEN_TEXT)
+ {
+ TOKEN_DATA_TYPE (argv[i]) = TOKEN_TEXT;
+ TOKEN_DATA_TEXT (argv[i]) = (char *) "";
+ }
call_macro (s, argc - 1, argv + 1, obs);
}
}
@@ -899,38 +899,38 @@ m4_defn (struct obstack *obs, int argc, token_data **argv)
{
s = lookup_symbol (ARG (i), SYMBOL_LOOKUP);
if (s == NULL)
- continue;
+ continue;
switch (SYMBOL_TYPE (s))
- {
- case TOKEN_TEXT:
- obstack_grow (obs, lquote.string, lquote.length);
- obstack_grow (obs, SYMBOL_TEXT (s), strlen (SYMBOL_TEXT (s)));
- obstack_grow (obs, rquote.string, rquote.length);
- break;
-
- case TOKEN_FUNC:
- b = SYMBOL_FUNC (s);
- if (b == m4_placeholder)
- M4ERROR ((warning_status, 0, "\
+ {
+ case TOKEN_TEXT:
+ obstack_grow (obs, lquote.string, lquote.length);
+ obstack_grow (obs, SYMBOL_TEXT (s), strlen (SYMBOL_TEXT (s)));
+ obstack_grow (obs, rquote.string, rquote.length);
+ break;
+
+ case TOKEN_FUNC:
+ b = SYMBOL_FUNC (s);
+ if (b == m4_placeholder)
+ M4ERROR ((warning_status, 0, "\
builtin `%s' requested by frozen file is not supported", ARG (i)));
- else if (argc != 2)
- M4ERROR ((warning_status, 0,
- "Warning: cannot concatenate builtin `%s'",
- ARG (i)));
- else
- push_macro (b);
- break;
-
- case TOKEN_VOID:
- /* Nothing to do for traced but undefined macro. */
- break;
-
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad symbol type in m4_defn ()"));
- abort ();
- }
+ else if (argc != 2)
+ M4ERROR ((warning_status, 0,
+ "Warning: cannot concatenate builtin `%s'",
+ ARG (i)));
+ else
+ push_macro (b);
+ break;
+
+ case TOKEN_VOID:
+ /* Nothing to do for traced but undefined macro. */
+ break;
+
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad symbol type in m4_defn ()"));
+ abort ();
+ }
}
}
@@ -967,7 +967,7 @@ m4_syscmd (struct obstack *obs M4_GNUC_UNUSED, int argc,
token_data **argv)
prog_args[2] = cmd;
errno = 0;
status = execute (ARG (0), 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);
@@ -976,7 +976,7 @@ m4_syscmd (struct obstack *obs M4_GNUC_UNUSED, int argc,
token_data **argv)
else
{
if (status == 127 && errno)
- M4ERROR ((warning_status, errno, "cannot run command `%s'", cmd));
+ M4ERROR ((warning_status, errno, "cannot run command `%s'", cmd));
sysval = status;
}
}
@@ -1010,7 +1010,7 @@ m4_esyscmd (struct obstack *obs, int argc, token_data
**argv)
prog_args[2] = cmd;
errno = 0;
child = create_pipe_in (ARG (0), SYSCMD_SHELL, (char **) prog_args,
- NULL, false, true, false, &fd);
+ NULL, false, true, false, &fd);
if (child == -1)
{
M4ERROR ((warning_status, errno, "cannot run command `%s'", cmd));
@@ -1030,23 +1030,23 @@ m4_esyscmd (struct obstack *obs, int argc, token_data
**argv)
size_t avail = obstack_room (obs);
size_t len;
if (!avail)
- {
- int ch = getc (pin);
- if (ch == EOF)
- break;
- obstack_1grow (obs, ch);
- continue;
- }
+ {
+ int ch = getc (pin);
+ if (ch == EOF)
+ break;
+ obstack_1grow (obs, ch);
+ continue;
+ }
len = fread (obstack_next_free (obs), 1, avail, pin);
if (len <= 0)
- break;
+ break;
obstack_blank_fast (obs, len);
}
if (ferror (pin) || fclose (pin))
M4ERROR ((EXIT_FAILURE, errno, "cannot read pipe"));
errno = 0;
status = wait_subprocess (child, ARG (0), false, true, true, false,
- &sig_status);
+ &sig_status);
if (sig_status)
{
assert (status == 127);
@@ -1055,14 +1055,14 @@ m4_esyscmd (struct obstack *obs, int argc, token_data
**argv)
else
{
if (status == 127 && errno)
- M4ERROR ((warning_status, errno, "cannot run command `%s'", cmd));
+ M4ERROR ((warning_status, errno, "cannot run command `%s'", cmd));
sysval = status;
}
}
static void
m4_sysval (struct obstack *obs, int argc M4_GNUC_UNUSED,
- token_data **argv M4_GNUC_UNUSED)
+ token_data **argv M4_GNUC_UNUSED)
{
shipout_int (obs, sysval);
}
@@ -1089,8 +1089,8 @@ m4_eval (struct obstack *obs, int argc, token_data **argv)
if (radix < 1 || radix > (int) strlen (digits))
{
M4ERROR ((warning_status, 0,
- "radix %d in builtin `%s' out of range",
- radix, ARG (0)));
+ "radix %d in builtin `%s' out of range",
+ radix, ARG (0)));
return;
}
@@ -1099,28 +1099,28 @@ m4_eval (struct obstack *obs, int argc, token_data
**argv)
if (min < 0)
{
M4ERROR ((warning_status, 0,
- "negative width to builtin `%s'", ARG (0)));
+ "negative width to builtin `%s'", ARG (0)));
return;
}
if (!*ARG (1))
M4ERROR ((warning_status, 0,
- "empty string treated as 0 in builtin `%s'", ARG (0)));
+ "empty string treated as 0 in builtin `%s'", ARG (0)));
else if (evaluate (ARG (1), &value))
return;
if (radix == 1)
{
if (value < 0)
- {
- obstack_1grow (obs, '-');
- value = -value;
- }
+ {
+ obstack_1grow (obs, '-');
+ value = -value;
+ }
/* This assumes 2's-complement for correctly handling INT_MIN. */
while (min-- - value > 0)
- obstack_1grow (obs, '0');
+ obstack_1grow (obs, '0');
while (value-- != 0)
- obstack_1grow (obs, '1');
+ obstack_1grow (obs, '1');
obstack_1grow (obs, '\0');
return;
}
@@ -1219,26 +1219,26 @@ m4_undivert (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
else
for (i = 1; i < argc; i++)
{
- file = strtol (ARG (i), &endp, 10);
- if (*endp == '\0' && !isspace (to_uchar (*ARG (i))))
- insert_diversion (file);
- else if (no_gnu_extensions)
- M4ERROR ((warning_status, 0,
- "non-numeric argument to builtin `%s'", ARG (0)));
- else
- {
- fp = m4_path_search (ARG (i), NULL);
- if (fp != NULL)
- {
- insert_file (fp);
- if (fclose (fp) == EOF)
- M4ERROR ((warning_status, errno,
- "error undiverting `%s'", ARG (i)));
- }
- else
- M4ERROR ((warning_status, errno,
- "cannot undivert `%s'", ARG (i)));
- }
+ file = strtol (ARG (i), &endp, 10);
+ if (*endp == '\0' && !isspace (to_uchar (*ARG (i))))
+ insert_diversion (file);
+ else if (no_gnu_extensions)
+ M4ERROR ((warning_status, 0,
+ "non-numeric argument to builtin `%s'", ARG (0)));
+ else
+ {
+ fp = m4_path_search (ARG (i), NULL);
+ if (fp != NULL)
+ {
+ insert_file (fp);
+ if (fclose (fp) == EOF)
+ M4ERROR ((warning_status, errno,
+ "error undiverting `%s'", ARG (i)));
+ }
+ else
+ M4ERROR ((warning_status, errno,
+ "cannot undivert `%s'", ARG (i)));
+ }
}
}
@@ -1279,14 +1279,14 @@ m4_shift (struct obstack *obs, int argc, token_data
**argv)
static void
m4_changequote (struct obstack *obs M4_GNUC_UNUSED, int argc,
- token_data **argv)
+ token_data **argv)
{
if (bad_argc (argv[0], argc, 1, 3))
return;
/* Explicit NULL distinguishes between empty and missing argument. */
set_quotes ((argc >= 2) ? TOKEN_DATA_TEXT (argv[1]) : NULL,
- (argc >= 3) ? TOKEN_DATA_TEXT (argv[2]) : NULL);
+ (argc >= 3) ? TOKEN_DATA_TEXT (argv[2]) : NULL);
}
/*--------------------------------------------------------------------.
@@ -1302,7 +1302,7 @@ m4_changecom (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
/* Explicit NULL distinguishes between empty and missing argument. */
set_comment ((argc >= 2) ? TOKEN_DATA_TEXT (argv[1]) : NULL,
- (argc >= 3) ? TOKEN_DATA_TEXT (argv[2]) : NULL);
+ (argc >= 3) ? TOKEN_DATA_TEXT (argv[2]) : NULL);
}
#ifdef ENABLE_CHANGEWORD
@@ -1345,10 +1345,10 @@ include (int argc, token_data **argv, bool silent)
if (fp == NULL)
{
if (!silent)
- {
- M4ERROR ((warning_status, errno, "cannot open `%s'", ARG (1)));
- retcode = EXIT_FAILURE;
- }
+ {
+ M4ERROR ((warning_status, errno, "cannot open `%s'", ARG (1)));
+ retcode = EXIT_FAILURE;
+ }
return;
}
@@ -1388,7 +1388,7 @@ m4_sinclude (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
OBS. Report errors on behalf of ME. */
static void
mkstemp_helper (struct obstack *obs, const char *me, const char *pattern,
- size_t len)
+ size_t len)
{
int fd;
size_t i;
@@ -1429,15 +1429,15 @@ m4_maketemp (struct obstack *obs, int argc, token_data
**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);
int len = strlen (str);
@@ -1446,19 +1446,19 @@ m4_maketemp (struct obstack *obs, int argc, token_data
**argv)
M4ERROR ((warning_status, 0, "recommend using mkstemp instead"));
for (i = len; i > 1; i--)
- if (str[i - 1] != 'X')
- break;
+ if (str[i - 1] != 'X')
+ break;
obstack_grow (obs, str, i);
str = ntoa ((int32_t) getpid (), 10);
len2 = strlen (str);
if (len2 > len - i)
- obstack_grow0 (obs, str + len2 - (len - i), len - i);
+ obstack_grow0 (obs, str + len2 - (len - i), len - i);
else
- {
- while (i++ < len - len2)
- obstack_1grow (obs, '0');
- obstack_grow0 (obs, str, len2);
- }
+ {
+ while (i++ < len - len2)
+ obstack_1grow (obs, '0');
+ obstack_grow0 (obs, str, len2);
+ }
}
else
mkstemp_helper (obs, ARG (0), ARG (1), strlen (ARG (1)));
@@ -1537,7 +1537,7 @@ m4_m4exit (struct obstack *obs M4_GNUC_UNUSED, int argc,
token_data **argv)
if (exit_code < 0 || exit_code > 255)
{
M4ERROR ((warning_status, 0,
- "exit status out of range: `%d'", exit_code));
+ "exit status out of range: `%d'", exit_code));
exit_code = EXIT_FAILURE;
}
/* Change debug stream back to stderr, to force flushing debug stream and
@@ -1601,10 +1601,10 @@ m4_traceon (struct obstack *obs, int argc, token_data
**argv)
else
for (i = 1; i < argc; i++)
{
- s = lookup_symbol (ARG (i), SYMBOL_LOOKUP);
- if (!s)
- s = lookup_symbol (ARG (i), SYMBOL_INSERT);
- set_trace (s, obs);
+ s = lookup_symbol (ARG (i), SYMBOL_LOOKUP);
+ if (!s)
+ s = lookup_symbol (ARG (i), SYMBOL_INSERT);
+ set_trace (s, obs);
}
}
@@ -1623,9 +1623,9 @@ m4_traceoff (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
else
for (i = 1; i < argc; i++)
{
- s = lookup_symbol (TOKEN_DATA_TEXT (argv[i]), SYMBOL_LOOKUP);
- if (s != NULL)
- set_trace (s, NULL);
+ s = lookup_symbol (TOKEN_DATA_TEXT (argv[i]), SYMBOL_LOOKUP);
+ if (s != NULL)
+ set_trace (s, NULL);
}
}
@@ -1649,41 +1649,41 @@ m4_debugmode (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
else
{
if (ARG (1)[0] == '+' || ARG (1)[0] == '-')
- {
- change_flag = ARG (1)[0];
- new_debug_level = debug_decode (ARG (1) + 1);
- }
+ {
+ change_flag = ARG (1)[0];
+ new_debug_level = debug_decode (ARG (1) + 1);
+ }
else
- {
- change_flag = 0;
- new_debug_level = debug_decode (ARG (1));
- }
+ {
+ change_flag = 0;
+ new_debug_level = debug_decode (ARG (1));
+ }
if (new_debug_level < 0)
- M4ERROR ((warning_status, 0,
- "Debugmode: bad debug flags: `%s'", ARG (1)));
+ M4ERROR ((warning_status, 0,
+ "Debugmode: bad debug flags: `%s'", ARG (1)));
else
- {
- switch (change_flag)
- {
- case 0:
- debug_level = new_debug_level;
- break;
-
- case '+':
- debug_level |= new_debug_level;
- break;
-
- case '-':
- debug_level &= ~new_debug_level;
- break;
-
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad flag in m4_debugmode ()"));
- abort ();
- }
- }
+ {
+ switch (change_flag)
+ {
+ case 0:
+ debug_level = new_debug_level;
+ break;
+
+ case '+':
+ debug_level |= new_debug_level;
+ break;
+
+ case '-':
+ debug_level &= ~new_debug_level;
+ break;
+
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad flag in m4_debugmode ()"));
+ abort ();
+ }
+ }
}
}
@@ -1702,7 +1702,7 @@ m4_debugfile (struct obstack *obs M4_GNUC_UNUSED, int
argc, token_data **argv)
debug_set_output (NULL);
else if (!debug_set_output (ARG (1)))
M4ERROR ((warning_status, errno,
- "cannot set debug file `%s'", ARG (1)));
+ "cannot set debug file `%s'", ARG (1)));
}
/* This section contains text processing macros: "len", "index",
@@ -1737,7 +1737,7 @@ m4_index (struct obstack *obs, int argc, token_data
**argv)
{
/* builtin(`index') is blank, but index(`abc') is 0. */
if (argc == 2)
- shipout_int (obs, 0);
+ shipout_int (obs, 0);
return;
}
@@ -1765,7 +1765,7 @@ m4_substr (struct obstack *obs, int argc, token_data
**argv)
{
/* builtin(`substr') is blank, but substr(`abc') is abc. */
if (argc == 2)
- obstack_grow (obs, ARG (1), strlen (ARG (1)));
+ obstack_grow (obs, ARG (1), strlen (ARG (1)));
return;
}
@@ -1803,27 +1803,27 @@ expand_ranges (const char *s, struct obstack *obs)
for (from = '\0'; *s != '\0'; from = to_uchar (*s++))
{
if (*s == '-' && from != '\0')
- {
- to = to_uchar (*++s);
- if (to == '\0')
- {
- /* trailing dash */
- obstack_1grow (obs, '-');
- break;
- }
- else if (from <= to)
- {
- while (from++ < to)
- obstack_1grow (obs, from);
- }
- else
- {
- while (--from >= to)
- obstack_1grow (obs, from);
- }
- }
+ {
+ to = to_uchar (*++s);
+ if (to == '\0')
+ {
+ /* trailing dash */
+ obstack_1grow (obs, '-');
+ break;
+ }
+ else 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);
}
obstack_1grow (obs, '\0');
return (char *) obstack_finish (obs);
@@ -1851,7 +1851,7 @@ m4_translit (struct obstack *obs, int argc, token_data
**argv)
{
/* builtin(`translit') is blank, but translit(`abc') is abc. */
if (2 <= argc)
- obstack_grow (obs, data, strlen (data));
+ obstack_grow (obs, data, strlen (data));
return;
}
@@ -1870,18 +1870,18 @@ m4_translit (struct obstack *obs, int argc, token_data
**argv)
const char *p;
size_t len = strlen (data);
while ((p = (char *) memchr2 (data, from[0], from[1], len)))
- {
- obstack_grow (obs, data, p - data);
- len -= p - data;
- if (!len)
- return;
- data = p + 1;
- len--;
- if (*p == from[0] && to[0])
- obstack_1grow (obs, to[0]);
- else if (*p == from[1] && to[0] && to[1])
- obstack_1grow (obs, to[1]);
- }
+ {
+ obstack_grow (obs, data, p - data);
+ len -= p - data;
+ if (!len)
+ return;
+ data = p + 1;
+ len--;
+ if (*p == from[0] && to[0])
+ obstack_1grow (obs, to[0]);
+ else if (*p == from[1] && to[0] && to[1])
+ obstack_1grow (obs, to[1]);
+ }
obstack_grow (obs, data, len);
return;
}
@@ -1903,20 +1903,20 @@ m4_translit (struct obstack *obs, int argc, token_data
**argv)
for ( ; (ch = *from) != '\0'; from++)
{
if (! found[ch])
- {
- found[ch] = 1;
- map[ch] = *to;
- }
+ {
+ found[ch] = 1;
+ map[ch] = *to;
+ }
if (*to != '\0')
- to++;
+ to++;
}
for (data = ARG (1); (ch = *data) != '\0'; data++)
{
if (! found[ch])
- obstack_1grow (obs, ch);
+ obstack_1grow (obs, ch);
else if (map[ch])
- obstack_1grow (obs, map[ch]);
+ obstack_1grow (obs, map[ch]);
}
}
@@ -1946,7 +1946,7 @@ static int substitute_warned = 0;
static void
substitute (struct obstack *obs, const char *victim, const char *repl,
- struct re_registers *regs)
+ struct re_registers *regs)
{
int ch;
__re_size_t ind;
@@ -1954,52 +1954,52 @@ substitute (struct obstack *obs, const char *victim,
const char *repl,
{
const char *backslash = strchr (repl, '\\');
if (!backslash)
- {
- obstack_grow (obs, repl, strlen (repl));
- return;
- }
+ {
+ obstack_grow (obs, repl, strlen (repl));
+ return;
+ }
obstack_grow (obs, repl, backslash - repl);
repl = backslash;
ch = *++repl;
switch (ch)
- {
- case '0':
- if (!substitute_warned)
- {
- M4ERROR ((warning_status, 0, "\
+ {
+ case '0':
+ if (!substitute_warned)
+ {
+ M4ERROR ((warning_status, 0, "\
Warning: \\0 will disappear, use \\& instead in replacements"));
- substitute_warned = 1;
- }
- /* Fall through. */
-
- case '&':
- obstack_grow (obs, victim + regs->start[0],
- regs->end[0] - regs->start[0]);
- repl++;
- break;
-
- case '1': case '2': case '3': case '4': case '5': case '6':
- case '7': case '8': case '9':
- ind = ch -= '0';
- if (regs->num_regs - 1 <= ind)
- M4ERROR ((warning_status, 0,
- "Warning: 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]);
- repl++;
- break;
-
- case '\0':
- M4ERROR ((warning_status, 0,
- "Warning: trailing \\ ignored in replacement"));
- return;
-
- default:
- obstack_1grow (obs, ch);
- repl++;
- break;
- }
+ substitute_warned = 1;
+ }
+ /* Fall through. */
+
+ case '&':
+ obstack_grow (obs, victim + regs->start[0],
+ regs->end[0] - regs->start[0]);
+ repl++;
+ break;
+
+ case '1': case '2': case '3': case '4': case '5': case '6':
+ case '7': case '8': case '9':
+ ind = ch -= '0';
+ if (regs->num_regs - 1 <= ind)
+ M4ERROR ((warning_status, 0,
+ "Warning: 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]);
+ repl++;
+ break;
+
+ case '\0':
+ M4ERROR ((warning_status, 0,
+ "Warning: trailing \\ ignored in replacement"));
+ return;
+
+ default:
+ obstack_1grow (obs, ch);
+ repl++;
+ break;
+ }
}
}
@@ -2045,7 +2045,7 @@ m4_regexp (struct obstack *obs, int argc, token_data
**argv)
{
/* builtin(`regexp') is blank, but regexp(`abc') is 0. */
if (argc == 2)
- shipout_int (obs, 0);
+ shipout_int (obs, 0);
return;
}
@@ -2058,7 +2058,7 @@ m4_regexp (struct obstack *obs, int argc, token_data
**argv)
if (msg != NULL)
{
M4ERROR ((warning_status, 0,
- "bad regular expression: `%s': %s", regexp, msg));
+ "bad regular expression: `%s': %s", regexp, msg));
free_pattern_buffer (&buf, ®s);
return;
}
@@ -2066,11 +2066,11 @@ m4_regexp (struct obstack *obs, int argc, token_data
**argv)
length = strlen (victim);
/* Avoid overhead of allocating regs if we won't use it. */
startpos = re_search (&buf, victim, length, 0, length,
- argc == 3 ? NULL : ®s);
+ argc == 3 ? NULL : ®s);
if (startpos == -2)
M4ERROR ((warning_status, 0,
- "error matching regular expression `%s'", regexp));
+ "error matching regular expression `%s'", regexp));
else if (argc == 3)
shipout_int (obs, startpos);
else if (startpos >= 0)
@@ -2106,7 +2106,7 @@ m4_patsubst (struct obstack *obs, int argc, token_data
**argv)
{
/* builtin(`patsubst') is blank, but patsubst(`abc') is abc. */
if (argc == 2)
- obstack_grow (obs, ARG (1), strlen (ARG (1)));
+ obstack_grow (obs, ARG (1), strlen (ARG (1)));
return;
}
@@ -2118,7 +2118,7 @@ m4_patsubst (struct obstack *obs, int argc, token_data
**argv)
if (msg != NULL)
{
M4ERROR ((warning_status, 0,
- "bad regular expression `%s': %s", regexp, msg));
+ "bad regular expression `%s': %s", regexp, msg));
free (buf.buffer);
return;
}
@@ -2131,38 +2131,38 @@ m4_patsubst (struct obstack *obs, int argc, token_data
**argv)
while (offset <= length)
{
matchpos = re_search (&buf, victim, length,
- offset, length - offset, ®s);
+ offset, length - offset, ®s);
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)
- M4ERROR ((warning_status, 0,
- "error matching regular expression `%s'", regexp));
- else if (offset < length)
- obstack_grow (obs, victim + offset, length - offset);
- break;
- }
+ if (matchpos == -2)
+ M4ERROR ((warning_status, 0,
+ "error matching regular expression `%s'", regexp));
+ 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, victim, ARG (3), ®s);
/* 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])
- obstack_1grow (obs, victim[offset++]);
+ obstack_1grow (obs, victim[offset++]);
}
obstack_1grow (obs, '\0');
@@ -2186,7 +2186,7 @@ m4_patsubst (struct obstack *obs, int argc, token_data
**argv)
void
m4_placeholder (struct obstack *obs M4_GNUC_UNUSED, int argc,
- token_data **argv)
+ token_data **argv)
{
M4ERROR ((warning_status, 0, "\
builtin `%s' requested by frozen file is not supported", ARG (0)));
@@ -2202,7 +2202,7 @@ builtin `%s' requested by frozen file is not supported",
ARG (0)));
void
expand_user_macro (struct obstack *obs, symbol *sym,
- int argc, token_data **argv)
+ int argc, token_data **argv)
{
const char *text = SYMBOL_TEXT (sym);
int i;
@@ -2210,44 +2210,44 @@ expand_user_macro (struct obstack *obs, symbol *sym,
{
const char *dollar = strchr (text, '$');
if (!dollar)
- {
- obstack_grow (obs, text, strlen (text));
- return;
- }
+ {
+ obstack_grow (obs, text, strlen (text));
+ return;
+ }
obstack_grow (obs, text, dollar - text);
text = dollar;
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';
- }
- else
- {
- for (i = 0; isdigit (to_uchar (*text)); text++)
- i = i*10 + (*text - '0');
- }
- if (i < argc)
- obstack_grow (obs, TOKEN_DATA_TEXT (argv[i]),
- strlen (TOKEN_DATA_TEXT (argv[i])));
- break;
-
- case '#': /* number of arguments */
- shipout_int (obs, argc - 1);
- text++;
- break;
-
- case '*': /* all arguments */
- case '@': /* ... same, but quoted */
- dump_args (obs, argc, argv, ",", *text == '@');
- text++;
- 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';
+ }
+ else
+ {
+ for (i = 0; isdigit (to_uchar (*text)); text++)
+ i = i*10 + (*text - '0');
+ }
+ if (i < argc)
+ obstack_grow (obs, TOKEN_DATA_TEXT (argv[i]),
+ strlen (TOKEN_DATA_TEXT (argv[i])));
+ break;
+
+ case '#': /* number of arguments */
+ shipout_int (obs, argc - 1);
+ text++;
+ break;
+
+ case '*': /* all arguments */
+ case '@': /* ... same, but quoted */
+ dump_args (obs, argc, argv, ",", *text == '@');
+ text++;
+ break;
+
+ default:
+ obstack_1grow (obs, '$');
+ break;
+ }
}
}
diff --git a/src/debug.c b/src/debug.c
index c13786c..507642c 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -60,57 +60,57 @@ debug_decode (const char *opts)
else
{
for (level = 0; *opts; 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 '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 'V':
+ level |= DEBUG_TRACE_VERBOSE;
+ break;
+
+ default:
+ return -1;
+ }
+ }
}
/* This is to avoid screwing up the trace output due to changes in the
@@ -143,24 +143,24 @@ debug_set_file (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)
- {
- M4ERROR ((warning_status, errno,
- "error writing to debug stream"));
- retcode = EXIT_FAILURE;
- }
- debug = stdout;
- }
+ && stdout_stat.st_dev == debug_stat.st_dev
+ && stdout_stat.st_ino != 0)
+ {
+ if (debug != stderr && close_stream (debug) != 0)
+ {
+ M4ERROR ((warning_status, errno,
+ "error writing to debug stream"));
+ retcode = EXIT_FAILURE;
+ }
+ debug = stdout;
+ }
}
}
@@ -214,11 +214,11 @@ debug_set_output (const char *name)
{
fp = fopen (name, "a");
if (fp == NULL)
- return false;
+ return false;
if (set_cloexec_flag (fileno (fp), true) != 0)
- M4ERROR ((warning_status, errno,
- "Warning: cannot protect debug file across forks"));
+ M4ERROR ((warning_status, errno,
+ "Warning: cannot protect debug file across forks"));
debug_set_file (fp);
}
return true;
@@ -270,48 +270,48 @@ trace_format (const char *fmt, ...)
while (true)
{
while ((ch = *fmt++) != '\0' && ch != '%')
- obstack_1grow (&trace, ch);
+ obstack_1grow (&trace, ch);
if (ch == '\0')
- break;
+ break;
maxlen = 0;
switch (*fmt++)
- {
- case 'S':
- maxlen = max_debug_argument_length;
- /* fall through */
+ {
+ case 'S':
+ maxlen = max_debug_argument_length;
+ /* fall through */
- case 's':
- s = va_arg (args, const char *);
- break;
+ case 's':
+ s = va_arg (args, const char *);
+ break;
- case 'l':
- s = (debug_level & DEBUG_TRACE_QUOTE) ? lquote.string : "";
- break;
+ case 'l':
+ s = (debug_level & DEBUG_TRACE_QUOTE) ? lquote.string : "";
+ break;
- case 'r':
- s = (debug_level & DEBUG_TRACE_QUOTE) ? rquote.string : "";
- break;
+ case 'r':
+ s = (debug_level & DEBUG_TRACE_QUOTE) ? rquote.string : "";
+ break;
- case 'd':
- d = va_arg (args, int);
- s = ntoa (d, 10);
- break;
+ case 'd':
+ d = va_arg (args, int);
+ s = ntoa (d, 10);
+ break;
- default:
- s = "";
- break;
- }
+ default:
+ s = "";
+ break;
+ }
slen = strlen (s);
if (maxlen == 0 || maxlen > slen)
- obstack_grow (&trace, s, slen);
+ obstack_grow (&trace, s, slen);
else
- {
- obstack_grow (&trace, s, maxlen);
- obstack_grow (&trace, "...", 3);
- }
+ {
+ obstack_grow (&trace, s, maxlen);
+ obstack_grow (&trace, "...", 3);
+ }
}
va_end (args);
@@ -328,9 +328,9 @@ trace_header (int id)
if (current_line)
{
if (debug_level & DEBUG_TRACE_FILE)
- trace_format ("%s:", current_file);
+ trace_format ("%s:", current_file);
if (debug_level & DEBUG_TRACE_LINE)
- trace_format ("%d:", current_line);
+ trace_format ("%d:", current_line);
}
trace_format (" -%d- ", expansion_level);
if (debug_level & DEBUG_TRACE_CALLID)
@@ -384,35 +384,35 @@ trace_pre (const char *name, int id, int argc, token_data
**argv)
trace_format ("(");
for (i = 1; i < argc; i++)
- {
- if (i != 1)
- trace_format (", ");
-
- switch (TOKEN_DATA_TYPE (argv[i]))
- {
- case TOKEN_TEXT:
- trace_format ("%l%S%r", TOKEN_DATA_TEXT (argv[i]));
- break;
-
- case TOKEN_FUNC:
- bp = find_builtin_by_addr (TOKEN_DATA_FUNC (argv[i]));
- if (bp == NULL)
- {
- M4ERROR ((warning_status, 0, "\
+ {
+ if (i != 1)
+ trace_format (", ");
+
+ switch (TOKEN_DATA_TYPE (argv[i]))
+ {
+ case TOKEN_TEXT:
+ trace_format ("%l%S%r", TOKEN_DATA_TEXT (argv[i]));
+ break;
+
+ case TOKEN_FUNC:
+ bp = find_builtin_by_addr (TOKEN_DATA_FUNC (argv[i]));
+ if (bp == NULL)
+ {
+ M4ERROR ((warning_status, 0, "\
INTERNAL ERROR: builtin not found in builtin table! (trace_pre ())"));
- abort ();
- }
- trace_format ("<%s>", bp->name);
- break;
-
- case TOKEN_VOID:
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad token data type (trace_pre ())"));
- abort ();
- }
-
- }
+ abort ();
+ }
+ trace_format ("<%s>", bp->name);
+ break;
+
+ case TOKEN_VOID:
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad token data type (trace_pre ())"));
+ abort ();
+ }
+
+ }
trace_format (")");
}
diff --git a/src/eval.c b/src/eval.c
index f55bf52..9d4c9e1 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -118,67 +118,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;
}
@@ -186,92 +186,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;
@@ -299,9 +299,9 @@ evaluate (const char *expr, 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;
}
switch (err)
@@ -311,49 +311,49 @@ evaluate (const char *expr, int32_t *val)
case MISSING_RIGHT:
M4ERROR ((warning_status, 0,
- "bad expression in eval (missing right parenthesis): %s",
- expr));
+ "bad expression in eval (missing right parenthesis): %s",
+ expr));
break;
case SYNTAX_ERROR:
M4ERROR ((warning_status, 0,
- "bad expression in eval: %s", expr));
+ "bad expression in eval: %s", expr));
break;
case UNKNOWN_INPUT:
M4ERROR ((warning_status, 0,
- "bad expression in eval (bad input): %s", expr));
+ "bad expression in eval (bad input): %s", expr));
break;
case EXCESS_INPUT:
M4ERROR ((warning_status, 0,
- "bad expression in eval (excess input): %s", expr));
+ "bad expression in eval (excess input): %s", expr));
break;
case INVALID_OPERATOR:
M4ERROR ((warning_status, 0,
- "invalid operator in eval: %s", expr));
+ "invalid operator in eval: %s", expr));
retcode = EXIT_FAILURE;
break;
case DIVIDE_ZERO:
M4ERROR ((warning_status, 0,
- "divide by zero in eval: %s", expr));
+ "divide by zero in eval: %s", expr));
break;
case MODULO_ZERO:
M4ERROR ((warning_status, 0,
- "modulo by zero in eval: %s", expr));
+ "modulo by zero in eval: %s", expr));
break;
case NEGATIVE_EXPONENT:
M4ERROR ((warning_status, 0,
- "negative exponent in eval: %s", expr));
+ "negative exponent in eval: %s", expr));
break;
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad error code in evaluate ()"));
+ "INTERNAL ERROR: bad error code in evaluate ()"));
abort ();
}
@@ -377,16 +377,16 @@ logical_or_term (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 (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;
@@ -408,16 +408,16 @@ logical_and_term (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 (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;
@@ -439,10 +439,10 @@ or_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = xor_term (et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 |= v2;
}
@@ -466,10 +466,10 @@ xor_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = and_term (et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 ^= v2;
}
@@ -493,10 +493,10 @@ and_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = equality_term (et, &v2)) != NO_ERROR)
- return er;
+ return er;
*v1 &= v2;
}
@@ -524,16 +524,16 @@ equality_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = cmp_term (et, &v2)) != NO_ERROR)
- return er;
+ return er;
if (op == ASSIGN)
{
- M4ERROR ((warning_status, 0, "\
+ M4ERROR ((warning_status, 0, "\
Warning: recommend ==, not =, for equality operator"));
- op = EQ;
+ op = EQ;
}
*v1 = (op == EQ) == (*v1 == v2);
}
@@ -555,39 +555,39 @@ cmp_term (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 (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:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad comparison operator in 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:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad comparison operator in cmp_term ()"));
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -612,36 +612,36 @@ shift_term (eval_token et, int32_t *v1)
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = add_term (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:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad shift operator in 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:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad shift operator in shift_term ()"));
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -664,19 +664,19 @@ add_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = mult_term (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;
@@ -699,46 +699,46 @@ mult_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = exp_term (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:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad operator in 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:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad operator in mult_term ()"));
+ abort ();
+ }
}
if (op == ERROR)
return UNKNOWN_INPUT;
@@ -761,22 +761,22 @@ exp_term (eval_token et, int32_t *v1)
{
et = eval_lex (&v2);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = exp_term (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)
@@ -796,21 +796,21 @@ unary_term (eval_token et, int32_t *v1)
{
et2 = eval_lex (v1);
if (et2 == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = unary_term (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 (et, v1)) != NO_ERROR)
return er;
@@ -829,17 +829,17 @@ simple_term (eval_token et, int32_t *v1)
case LEFTP:
et = eval_lex (v1);
if (et == ERROR)
- return UNKNOWN_INPUT;
+ return UNKNOWN_INPUT;
if ((er = logical_or_term (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 d38f2d4..54b7584 100644
--- a/src/format.c
+++ b/src/format.c
@@ -100,20 +100,20 @@ arg_double (const char *str)
}
#define ARG_INT(argc, argv) \
- ((argc == 0) ? 0 : \
- (--argc, argv++, arg_int (TOKEN_DATA_TEXT (argv[-1]))))
+ ((argc == 0) ? 0 : \
+ (--argc, argv++, arg_int (TOKEN_DATA_TEXT (argv[-1]))))
#define ARG_LONG(argc, argv) \
- ((argc == 0) ? 0 : \
- (--argc, argv++, arg_long (TOKEN_DATA_TEXT (argv[-1]))))
+ ((argc == 0) ? 0 : \
+ (--argc, argv++, arg_long (TOKEN_DATA_TEXT (argv[-1]))))
#define ARG_STR(argc, argv) \
- ((argc == 0) ? "" : \
- (--argc, argv++, TOKEN_DATA_TEXT (argv[-1])))
+ ((argc == 0) ? "" : \
+ (--argc, argv++, TOKEN_DATA_TEXT (argv[-1])))
#define ARG_DOUBLE(argc, argv) \
- ((argc == 0) ? 0 : \
- (--argc, argv++, arg_double (TOKEN_DATA_TEXT (argv[-1]))))
+ ((argc == 0) ? 0 : \
+ (--argc, argv++, arg_double (TOKEN_DATA_TEXT (argv[-1]))))
/*------------------------------------------------------------------.
@@ -165,220 +165,220 @@ expand_format (struct obstack *obs, int argc,
token_data **argv)
{
const char *percent = strchr (fmt, '%');
if (!percent)
- {
- obstack_grow (obs, fmt, strlen (fmt));
- return;
- }
+ {
+ obstack_grow (obs, fmt, strlen (fmt));
+ return;
+ }
obstack_grow (obs, fmt, percent - fmt);
fmt = percent + 1;
if (*fmt == '%')
- {
- obstack_1grow (obs, '%');
- fmt++;
- continue;
- }
+ {
+ obstack_1grow (obs, '%');
+ fmt++;
+ 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) && 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 (argc, argv);
- fmt++;
- }
+ {
+ width = ARG_INT (argc, argv);
+ fmt++;
+ }
else
- while (isdigit (to_uchar (*fmt)))
- {
- width = 10 * width + *fmt - '0';
- fmt++;
- }
+ while (isdigit (to_uchar (*fmt)))
+ {
+ width = 10 * width + *fmt - '0';
+ fmt++;
+ }
/* 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;
- if (*(++fmt) == '*')
- {
- prec = ARG_INT (argc, argv);
- ++fmt;
- }
- else
- {
- prec = 0;
- while (isdigit (to_uchar (*fmt)))
- {
- prec = 10 * prec + *fmt - '0';
- fmt++;
- }
- }
- }
+ {
+ ok['c'] = 0;
+ if (*(++fmt) == '*')
+ {
+ prec = ARG_INT (argc, argv);
+ ++fmt;
+ }
+ else
+ {
+ prec = 0;
+ while (isdigit (to_uchar (*fmt)))
+ {
+ prec = 10 * prec + *fmt - '0';
+ fmt++;
+ }
+ }
+ }
/* Length modifiers. We don't yet recognize ll, j, t, or z. */
if (*fmt == 'l')
- {
- *p++ = 'l';
- lflag = 1;
- fmt++;
- ok['c'] = ok['s'] = 0;
- }
+ {
+ *p++ = 'l';
+ lflag = 1;
+ fmt++;
+ ok['c'] = ok['s'] = 0;
+ }
else if (*fmt == 'h')
- {
- *p++ = 'h';
- fmt++;
- if (*fmt == 'h')
- {
- *p++ = 'h';
- fmt++;
- }
- ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E'] = ok['f'] = ok['F']
- = ok['g'] = ok['G'] = ok['s'] = 0;
- }
+ {
+ *p++ = 'h';
+ fmt++;
+ if (*fmt == 'h')
+ {
+ *p++ = 'h';
+ fmt++;
+ }
+ 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])
- {
- M4ERROR ((warning_status, 0,
- "Warning: unrecognized specifier in `%s'", f));
- if (c == '\0')
- fmt--;
- continue;
- }
+ {
+ M4ERROR ((warning_status, 0,
+ "Warning: unrecognized specifier in `%s'", f));
+ if (c == '\0')
+ fmt--;
+ continue;
+ }
/* 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:
- str = xasprintf (fstart, width, ARG_INT(argc, argv));
- break;
+ {
+ case CHAR:
+ str = xasprintf (fstart, width, ARG_INT(argc, argv));
+ break;
- case INT:
- str = xasprintf (fstart, width, prec, ARG_INT(argc, argv));
- break;
+ case INT:
+ str = xasprintf (fstart, width, prec, ARG_INT(argc, argv));
+ break;
- case LONG:
- str = xasprintf (fstart, width, prec, ARG_LONG(argc, argv));
- break;
+ case LONG:
+ str = xasprintf (fstart, width, prec, ARG_LONG(argc, argv));
+ break;
- case DOUBLE:
- str = xasprintf (fstart, width, prec, ARG_DOUBLE(argc, argv));
- break;
+ case DOUBLE:
+ str = xasprintf (fstart, width, prec, ARG_DOUBLE(argc, argv));
+ break;
- case STR:
- str = xasprintf (fstart, width, prec, ARG_STR(argc, argv));
- break;
+ case STR:
+ str = xasprintf (fstart, width, prec, ARG_STR(argc, argv));
+ break;
- default:
- abort();
- }
+ default:
+ abort();
+ }
/* NULL was returned on failure, such as invalid format string. For
- now, just silently ignore that bad specifier. */
+ now, just silently ignore that bad specifier. */
if (str == NULL)
- continue;
+ continue;
obstack_grow (obs, str, strlen (str));
free (str);
diff --git a/src/freeze.c b/src/freeze.c
index 518f1cb..b59ed0d 100644
--- a/src/freeze.c
+++ b/src/freeze.c
@@ -66,7 +66,7 @@ produce_frozen_state (const char *name)
/* 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. */
@@ -95,50 +95,50 @@ produce_frozen_state (const char *name)
{
/* Process all entries in one bucket, from the last to the first.
- This order ensures that, at reload time, pushdef's will be
- executed with the oldest definitions first. */
+ This order ensures that, at reload time, pushdef's will be
+ executed with the oldest definitions first. */
symtab[h] = reverse_symbol_list (symtab[h]);
for (sym = symtab[h]; sym; sym = SYMBOL_NEXT (sym))
- {
- switch (SYMBOL_TYPE (sym))
- {
- case TOKEN_TEXT:
- xfprintf (file, "T%d,%d\n",
- (int) strlen (SYMBOL_NAME (sym)),
- (int) strlen (SYMBOL_TEXT (sym)));
- fputs (SYMBOL_NAME (sym), file);
- fputs (SYMBOL_TEXT (sym), file);
- fputc ('\n', file);
- break;
-
- case TOKEN_FUNC:
- bp = find_builtin_by_addr (SYMBOL_FUNC (sym));
- if (bp == NULL)
- {
- M4ERROR ((warning_status, 0, "\
+ {
+ switch (SYMBOL_TYPE (sym))
+ {
+ case TOKEN_TEXT:
+ xfprintf (file, "T%d,%d\n",
+ (int) strlen (SYMBOL_NAME (sym)),
+ (int) strlen (SYMBOL_TEXT (sym)));
+ fputs (SYMBOL_NAME (sym), file);
+ fputs (SYMBOL_TEXT (sym), file);
+ fputc ('\n', file);
+ break;
+
+ case TOKEN_FUNC:
+ bp = find_builtin_by_addr (SYMBOL_FUNC (sym));
+ if (bp == NULL)
+ {
+ M4ERROR ((warning_status, 0, "\
INTERNAL ERROR: builtin not found in builtin table!"));
- abort ();
- }
- xfprintf (file, "F%d,%d\n",
- (int) strlen (SYMBOL_NAME (sym)),
- (int) strlen (bp->name));
- fputs (SYMBOL_NAME (sym), file);
- fputs (bp->name, file);
- fputc ('\n', file);
- break;
-
- case TOKEN_VOID:
- /* Ignore placeholder tokens that exist due to traceon. */
- break;
-
- default:
- M4ERROR ((warning_status, 0, "\
+ abort ();
+ }
+ xfprintf (file, "F%d,%d\n",
+ (int) strlen (SYMBOL_NAME (sym)),
+ (int) strlen (bp->name));
+ fputs (SYMBOL_NAME (sym), file);
+ fputs (bp->name, file);
+ fputc ('\n', file);
+ break;
+
+ case TOKEN_VOID:
+ /* Ignore placeholder tokens that exist due to traceon. */
+ break;
+
+ default:
+ M4ERROR ((warning_status, 0, "\
INTERNAL ERROR: bad token data type in freeze_one_symbol ()"));
- abort ();
- break;
- }
- }
+ abort ();
+ break;
+ }
+ }
/* Reverse the bucket once more, putting it back as it was. */
@@ -168,7 +168,7 @@ issue_expect_message (int expected)
M4ERROR ((EXIT_FAILURE, 0, "expecting line feed in frozen file"));
else
M4ERROR ((EXIT_FAILURE, 0, "expecting character `%c' in frozen file",
- expected));
+ expected));
}
/*-------------------------------------------------.
@@ -193,13 +193,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)
@@ -208,14 +208,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, \
- _("integer overflow in frozen file")); \
+ || isdigit (character)) \
+ m4_error (EXIT_FAILURE, 0, \
+ _("integer overflow in frozen file")); \
(Number) = n; \
} \
while (0)
@@ -224,7 +224,7 @@ reload_frozen_state (const char *name)
do \
{ \
if (character != (Expected)) \
- issue_expect_message (Expected); \
+ issue_expect_message (Expected); \
} \
while (0)
@@ -236,11 +236,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')
@@ -250,22 +250,22 @@ 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, \
- _("premature end of frozen file")); \
+ && !fread (string[(i)], (size_t) number[(i)], 1, file)) \
+ m4_error (EXIT_FAILURE, 0, \
+ _("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)
@@ -286,101 +286,101 @@ reload_frozen_state (const char *name)
GET_NUMBER (number[0], false);
if (number[0] > 1)
M4ERROR ((EXIT_MISMATCH, 0,
- "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)
M4ERROR ((EXIT_FAILURE, 0,
- "ill-formed frozen file, version directive expected"));
+ "ill-formed frozen file, version directive expected"));
VALIDATE ('\n');
GET_DIRECTIVE;
while (character != EOF)
{
switch (character)
- {
- default:
- M4ERROR ((EXIT_FAILURE, 0, "ill-formed frozen file"));
+ {
+ default:
+ M4ERROR ((EXIT_FAILURE, 0, "ill-formed frozen file"));
- case 'C':
- case 'D':
- case 'F':
- case 'T':
- case 'Q':
- operation = character;
- GET_CHARACTER;
+ case 'C':
+ case 'D':
+ case 'F':
+ case 'T':
+ case 'Q':
+ operation = character;
+ GET_CHARACTER;
- /* Get string lengths. Accept a negative diversion number. */
+ /* 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' && 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');
+ if (operation != 'D')
+ GET_STRING (0);
+ GET_STRING (1);
+ GET_CHARACTER;
+ VALIDATE ('\n');
- /* Act according to operation letter. */
+ /* Act according to operation letter. */
- switch (operation)
- {
- case 'C':
+ switch (operation)
+ {
+ case 'C':
- /* Change comment strings. */
+ /* Change comment strings. */
- set_comment (string[0], string[1]);
- break;
+ set_comment (string[0], string[1]);
+ break;
- case 'D':
+ case 'D':
- /* Select a diversion and add a string to it. */
+ /* Select a diversion and add a string to it. */
- make_diversion (number[0]);
- if (number[1] > 0)
- output_text (string[1], number[1]);
- break;
+ make_diversion (number[0]);
+ if (number[1] > 0)
+ output_text (string[1], number[1]);
+ break;
- case 'F':
+ case 'F':
- /* Enter a macro having a builtin function as a definition. */
+ /* Enter a macro having a builtin function as a definition. */
- bp = find_builtin_by_name (string[1]);
- define_builtin (string[0], bp, SYMBOL_PUSHDEF);
- break;
+ bp = find_builtin_by_name (string[1]);
+ define_builtin (string[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], string[1], SYMBOL_PUSHDEF);
- break;
+ define_user_macro (string[0], string[1], SYMBOL_PUSHDEF);
+ break;
- case 'Q':
+ case 'Q':
- /* Change quote strings. */
+ /* Change quote strings. */
- set_quotes (string[0], string[1]);
- break;
+ set_quotes (string[0], string[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 7336c53..1fa3a77 100644
--- a/src/input.c
+++ b/src/input.c
@@ -82,19 +82,19 @@ struct input_block
union
{
struct
- {
- char *string; /* remaining string value */
- char *end; /* terminating NUL of string */
- }
- u_s; /* INPUT_STRING */
+ {
+ char *string; /* remaining string value */
+ char *end; /* terminating NUL of string */
+ }
+ 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 if we should 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 if we should close file on pop */
+ bool_bitfield advance : 1; /* track previous start_of_input_line */
+ }
+ u_f; /* INPUT_FILE */
builtin_func *func; /* pointer to macro's function */
}
u;
@@ -190,7 +190,7 @@ push_file (FILE *fp, const char *title, bool
close_when_done)
DEBUG_MESSAGE1 ("input read from %s", title);
i = (input_block *) obstack_alloc (current_input,
- sizeof (struct input_block));
+ sizeof (struct input_block));
i->type = INPUT_FILE;
i->file = (char *) obstack_copy0 (&file_names, title, strlen (title));
i->line = 1;
@@ -224,7 +224,7 @@ push_macro (builtin_func *func)
}
i = (input_block *) obstack_alloc (current_input,
- sizeof (struct input_block));
+ sizeof (struct input_block));
i->type = INPUT_MACRO;
i->file = current_file;
i->line = current_line;
@@ -246,12 +246,12 @@ push_string_init (void)
if (next != NULL)
{
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: recursive push_string!"));
+ "INTERNAL ERROR: recursive push_string!"));
abort ();
}
next = (input_block *) obstack_alloc (current_input,
- sizeof (struct input_block));
+ sizeof (struct input_block));
next->type = INPUT_STRING;
next->file = current_file;
next->line = current_line;
@@ -308,7 +308,7 @@ push_wrapup (const char *s)
size_t len = strlen (s);
input_block *i;
i = (input_block *) obstack_alloc (wrapup_stack,
- sizeof (struct input_block));
+ sizeof (struct input_block));
i->prev = wsp;
i->type = INPUT_STRING;
i->file = current_file;
@@ -338,33 +338,33 @@ pop_input (void)
case INPUT_FILE:
if (debug_level & DEBUG_TRACE_INPUT)
- {
- if (tmp)
- DEBUG_MESSAGE2 ("input reverted to %s, line %d",
- tmp->file, tmp->line);
- else
- DEBUG_MESSAGE ("input exhausted");
- }
+ {
+ if (tmp)
+ DEBUG_MESSAGE2 ("input reverted to %s, line %d",
+ tmp->file, tmp->line);
+ else
+ DEBUG_MESSAGE ("input exhausted");
+ }
if (ferror (isp->u.u_f.fp))
- {
- M4ERROR ((warning_status, 0, "read error"));
- if (isp->u.u_f.close)
- fclose (isp->u.u_f.fp);
- retcode = EXIT_FAILURE;
- }
+ {
+ M4ERROR ((warning_status, 0, "read error"));
+ if (isp->u.u_f.close)
+ fclose (isp->u.u_f.fp);
+ retcode = EXIT_FAILURE;
+ }
else if (isp->u.u_f.close && fclose (isp->u.u_f.fp) == EOF)
- {
- M4ERROR ((warning_status, errno, "error reading file"));
- retcode = EXIT_FAILURE;
- }
+ {
+ M4ERROR ((warning_status, errno, "error reading file"));
+ retcode = EXIT_FAILURE;
+ }
start_of_input_line = isp->u.u_f.advance;
output_current_line = -1;
break;
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: input stack botch in pop_input ()"));
+ "INTERNAL ERROR: input stack botch in pop_input ()"));
abort ();
}
obstack_free (current_input, isp);
@@ -390,7 +390,7 @@ pop_wrapup (void)
if (wsp == NULL)
{
/* 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);
@@ -423,7 +423,7 @@ init_macro_token (token_data *td)
if (isp->type != INPUT_MACRO)
{
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad call to init_macro_token ()"));
+ "INTERNAL ERROR: bad call to init_macro_token ()"));
abort ();
}
@@ -448,34 +448,34 @@ peek_input (void)
while (1)
{
if (block == NULL)
- return CHAR_EOF;
+ return CHAR_EOF;
switch (block->type)
- {
- case INPUT_STRING:
- ch = to_uchar (block->u.u_s.string[0]);
- if (ch != '\0')
- return ch;
- break;
-
- 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_MACRO:
- return CHAR_MACRO;
-
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: input stack botch in peek_input ()"));
- abort ();
- }
+ {
+ case INPUT_STRING:
+ ch = to_uchar (block->u.u_s.string[0]);
+ if (ch != '\0')
+ return ch;
+ break;
+
+ 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_MACRO:
+ return CHAR_MACRO;
+
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: input stack botch in peek_input ()"));
+ abort ();
+ }
block = block->prev;
}
}
@@ -504,56 +504,56 @@ next_char_1 (void)
while (1)
{
if (isp == NULL)
- {
- current_file = "";
- current_line = 0;
- return CHAR_EOF;
- }
+ {
+ current_file = "";
+ current_line = 0;
+ return CHAR_EOF;
+ }
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:
- ch = to_uchar (*isp->u.u_s.string++);
- if (ch != '\0')
- return ch;
- break;
-
- 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_MACRO:
- pop_input (); /* INPUT_MACRO input sources has only one
- token */
- return CHAR_MACRO;
-
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: input stack botch in next_char ()"));
- abort ();
- }
+ {
+ case INPUT_STRING:
+ ch = to_uchar (*isp->u.u_s.string++);
+ if (ch != '\0')
+ return ch;
+ break;
+
+ 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_MACRO:
+ pop_input (); /* INPUT_MACRO input sources has only
one
+ token */
+ return CHAR_MACRO;
+
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: input stack botch in next_char ()"));
+ abort ();
+ }
/* End of input source --- pop one level. */
pop_input ();
@@ -578,7 +578,7 @@ skip_line (void)
/* current_file changed to "" if we see CHAR_EOF, use the
previous value we stored earlier. */
M4ERROR_AT_LINE ((warning_status, 0, file, line,
- "Warning: end of file treated as newline"));
+ "Warning: end of file treated as newline"));
/* On the rare occasion that dnl crosses include file boundaries
(either the input file did not end in a newline, or changeword
was used), calling next_char can update current_file and
@@ -612,7 +612,7 @@ match_input (const char *s, bool consume)
if (s[1] == '\0')
{
if (consume)
- (void) next_char ();
+ (void) next_char ();
return true; /* short match */
}
@@ -622,12 +622,12 @@ match_input (const char *s, bool consume)
(void) next_char ();
n++;
if (*s == '\0') /* long match */
- {
- if (consume)
- return true;
- result = true;
- break;
- }
+ {
+ if (consume)
+ return true;
+ result = true;
+ break;
+ }
}
/* Failed or shouldn't consume, push back input. */
@@ -781,7 +781,7 @@ set_word_regexp (const char *regexp)
if (msg != NULL)
{
M4ERROR ((warning_status, 0,
- "bad regular expression `%s': %s", regexp, msg));
+ "bad regular expression `%s': %s", regexp, msg));
return;
}
@@ -851,7 +851,7 @@ next_token (token_data *td, int *line)
next_char ();
#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
return TOKEN_MACDEF;
}
@@ -863,15 +863,15 @@ next_token (token_data *td, int *line)
{
obstack_grow (&token_stack, bcomm.string, bcomm.length);
while ((ch = next_char ()) != CHAR_EOF
- && !MATCH (ch, ecomm.string, true))
- obstack_1grow (&token_stack, ch);
+ && !MATCH (ch, ecomm.string, true))
+ obstack_1grow (&token_stack, ch);
if (ch != CHAR_EOF)
- obstack_grow (&token_stack, ecomm.string, ecomm.length);
+ obstack_grow (&token_stack, ecomm.string, ecomm.length);
else
- /* current_file changed to "" if we see CHAR_EOF, use the
- previous value we stored earlier. */
- M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, *line,
- "ERROR: end of file in comment"));
+ /* current_file changed to "" if we see CHAR_EOF, use the
+ previous value we stored earlier. */
+ M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, *line,
+ "ERROR: end of file in comment"));
type = TOKEN_STRING;
}
@@ -879,10 +879,10 @@ next_token (token_data *td, int *line)
{
obstack_1grow (&token_stack, ch);
while ((ch = peek_input ()) != CHAR_EOF && (isalnum (ch) || ch == '_'))
- {
- obstack_1grow (&token_stack, ch);
- (void) next_char ();
- }
+ {
+ obstack_1grow (&token_stack, ch);
+ (void) next_char ();
+ }
type = TOKEN_WORD;
}
@@ -892,33 +892,33 @@ next_token (token_data *td, int *line)
{
obstack_1grow (&token_stack, ch);
while (1)
- {
- ch = peek_input ();
- if (ch == CHAR_EOF)
- break;
- obstack_1grow (&token_stack, ch);
- startpos = re_search (&word_regexp,
- (char *) obstack_base (&token_stack),
- obstack_object_size (&token_stack), 0, 0,
- ®s);
- if (startpos ||
- regs.end [0] != (regoff_t) obstack_object_size (&token_stack))
- {
- *(((char *) obstack_base (&token_stack)
- + obstack_object_size (&token_stack)) - 1) = '\0';
- break;
- }
- next_char ();
- }
+ {
+ ch = peek_input ();
+ if (ch == CHAR_EOF)
+ break;
+ obstack_1grow (&token_stack, ch);
+ startpos = re_search (&word_regexp,
+ (char *) obstack_base (&token_stack),
+ obstack_object_size (&token_stack), 0, 0,
+ ®s);
+ if (startpos ||
+ regs.end [0] != (regoff_t) obstack_object_size (&token_stack))
+ {
+ *(((char *) obstack_base (&token_stack)
+ + obstack_object_size (&token_stack)) - 1) = '\0';
+ break;
+ }
+ next_char ();
+ }
obstack_1grow (&token_stack, '\0');
orig_text = (char *) obstack_finish (&token_stack);
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;
}
@@ -928,20 +928,20 @@ next_token (token_data *td, int *line)
else if (!MATCH (ch, lquote.string, true))
{
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);
}
else
@@ -949,64 +949,64 @@ next_token (token_data *td, int *line)
bool fast = lquote.length == 1 && rquote.length == 1;
quote_level = 1;
while (1)
- {
- /* Try scanning a buffer first. */
- const char *buffer = (isp && isp->type == INPUT_STRING
- ? isp->u.u_s.string : NULL);
- if (buffer && *buffer)
- {
- size_t len = isp->u.u_s.end - buffer;
- const char *p = buffer;
- do
- {
- p = (char *) memchr2 (p, *lquote.string, *rquote.string,
- buffer + len - p);
- }
- while (p && fast && (*p++ == *rquote.string
- ? --quote_level : ++quote_level));
- if (p)
- {
- if (fast)
- {
- assert (!quote_level);
- obstack_grow (&token_stack, buffer, p - buffer - 1);
- isp->u.u_s.string += p - buffer;
- break;
- }
- obstack_grow (&token_stack, buffer, p - buffer);
- ch = to_uchar (*p);
- isp->u.u_s.string += p - buffer + 1;
- }
- else
- {
- obstack_grow (&token_stack, buffer, len);
- isp->u.u_s.string += len;
- continue;
- }
- }
- /* Fall back to a byte. */
- else
- ch = next_char ();
- if (ch == CHAR_EOF)
- /* current_file changed to "" if we see CHAR_EOF, use
- the previous value we stored earlier. */
- M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, *line,
- "ERROR: end of file in string"));
-
- if (MATCH (ch, rquote.string, true))
- {
- if (--quote_level == 0)
- break;
- obstack_grow (&token_stack, rquote.string, rquote.length);
- }
- else if (MATCH (ch, lquote.string, true))
- {
- quote_level++;
- obstack_grow (&token_stack, lquote.string, lquote.length);
- }
- else
- obstack_1grow (&token_stack, ch);
- }
+ {
+ /* Try scanning a buffer first. */
+ const char *buffer = (isp && isp->type == INPUT_STRING
+ ? isp->u.u_s.string : NULL);
+ if (buffer && *buffer)
+ {
+ size_t len = isp->u.u_s.end - buffer;
+ const char *p = buffer;
+ do
+ {
+ p = (char *) memchr2 (p, *lquote.string, *rquote.string,
+ buffer + len - p);
+ }
+ while (p && fast && (*p++ == *rquote.string
+ ? --quote_level : ++quote_level));
+ if (p)
+ {
+ if (fast)
+ {
+ assert (!quote_level);
+ obstack_grow (&token_stack, buffer, p - buffer - 1);
+ isp->u.u_s.string += p - buffer;
+ break;
+ }
+ obstack_grow (&token_stack, buffer, p - buffer);
+ ch = to_uchar (*p);
+ isp->u.u_s.string += p - buffer + 1;
+ }
+ else
+ {
+ obstack_grow (&token_stack, buffer, len);
+ isp->u.u_s.string += len;
+ continue;
+ }
+ }
+ /* Fall back to a byte. */
+ else
+ ch = next_char ();
+ if (ch == CHAR_EOF)
+ /* current_file changed to "" if we see CHAR_EOF, use
+ the previous value we stored earlier. */
+ M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, *line,
+ "ERROR: end of file in string"));
+
+ if (MATCH (ch, rquote.string, true))
+ {
+ if (--quote_level == 0)
+ break;
+ obstack_grow (&token_stack, rquote.string, rquote.length);
+ }
+ else if (MATCH (ch, lquote.string, true))
+ {
+ quote_level++;
+ obstack_grow (&token_stack, lquote.string, lquote.length);
+ }
+ else
+ obstack_1grow (&token_stack, ch);
+ }
type = TOKEN_STRING;
}
@@ -1021,7 +1021,7 @@ next_token (token_data *td, int *line)
#endif
#ifdef DEBUG_INPUT
xfprintf (stderr, "next_token -> %s (%s)\n",
- token_type_string (type), TOKEN_DATA_TEXT (td));
+ token_type_string (type), TOKEN_DATA_TEXT (td));
#endif
return type;
}
@@ -1064,16 +1064,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 496b6e0..63517bb 100644
--- a/src/m4.c
+++ b/src/m4.c
@@ -97,7 +97,7 @@ m4_error (int status, int errnum, const char *format, ...)
va_list args;
va_start (args, format);
verror_at_line (status, errnum, current_line ? current_file : NULL,
- current_line, format, args);
+ current_line, format, args);
if (fatal_warnings && ! retcode)
retcode = EXIT_FAILURE;
}
@@ -108,7 +108,7 @@ m4_error (int status, int errnum, const char *format, ...)
void
m4_error_at_line (int status, int errnum, const char *file, int line,
- const char *format, ...)
+ const char *format, ...)
{
va_list args;
va_start (args, format);
@@ -126,7 +126,7 @@ m4_error_at_line (int status, int errnum, const char *file,
int line,
# define MAX(a,b) ((a) < (b) ? (b) : (a))
# endif
# define NSIG (MAX (SIGABRT, MAX (SIGILL, MAX (SIGFPE, \
- MAX (SIGSEGV, SIGBUS)))) + 1)
+ MAX (SIGSEGV, SIGBUS)))) + 1)
#endif
/* Pre-translated messages for program errors. Do not translate in
@@ -145,22 +145,22 @@ fault_handler (int signo)
if (signo)
{
/* POSIX states that reading static memory is, in general, not
- async-safe. However, the static variables that we read are
- never modified once this handler is installed, so this
- particular usage is safe. And it seems an oversight that
- POSIX claims strlen is not async-safe. Ignore write
- failures, since we will exit with non-zero status anyway. */
+ async-safe. However, the static variables that we read are
+ never modified once this handler is installed, so this
+ particular usage is safe. And it seems an oversight that
+ POSIX claims strlen is not async-safe. Ignore write
+ failures, since we will exit with non-zero status anyway. */
#define WRITE(f, b, l) ignore_value (write (f, b, l))
WRITE (STDERR_FILENO, program_name, strlen (program_name));
WRITE (STDERR_FILENO, ": ", 2);
WRITE (STDERR_FILENO, program_error_message,
- strlen (program_error_message));
+ strlen (program_error_message));
if (signal_message[signo])
- {
- WRITE (STDERR_FILENO, ": ", 2);
- WRITE (STDERR_FILENO, signal_message[signo],
- strlen (signal_message[signo]));
- }
+ {
+ WRITE (STDERR_FILENO, ": ", 2);
+ WRITE (STDERR_FILENO, signal_message[signo],
+ strlen (signal_message[signo]));
+ }
WRITE (STDERR_FILENO, "\n", 1);
#undef WRITE
_exit (EXIT_INTERNAL_ERROR);
@@ -326,9 +326,9 @@ 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. */
push_file (stdin, "stdin", false);
}
else
@@ -336,13 +336,13 @@ 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'"), 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'"), 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);
}
@@ -392,7 +392,7 @@ main (int argc, char *const *argv)
handlers. */
program_error_message
= xasprintf (_("internal error detected; please report this bug to <%s>"),
- PACKAGE_BUGREPORT);
+ PACKAGE_BUGREPORT);
signal_message[SIGSEGV] = xstrdup (strsignal (SIGSEGV));
signal_message[SIGABRT] = xstrdup (strsignal (SIGABRT));
signal_message[SIGILL] = xstrdup (strsignal (SIGILL));
@@ -420,10 +420,10 @@ main (int argc, char *const *argv)
char *crash = getenv ("M4_CRASH");
if (crash)
{
- if (!strtol (crash, NULL, 10))
- ++*(int *) 8;
- assert (false);
- abort ();
+ if (!strtol (crash, NULL, 10))
+ ++*(int *) 8;
+ assert (false);
+ abort ();
}
}
#endif /* DEBUG_STKOVF */
@@ -432,28 +432,28 @@ main (int argc, char *const *argv)
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 'N':
case DIVERSIONS_OPTION:
- /* -N became an obsolete no-op in 1.4.x. */
- error (0, 0, _("warning: `m4 %s' is deprecated"),
- optchar == 'N' ? "-N" : "--diversions");
- break;
+ /* -N became an obsolete no-op in 1.4.x. */
+ error (0, 0, _("warning: `m4 %s' is deprecated"),
+ optchar == 'N' ? "-N" : "--diversions");
+ break;
case 'D':
case 'U':
@@ -461,119 +461,119 @@ main (int argc, char *const *argv)
case 't':
case '\1':
case DEBUGFILE_OPTION:
- /* 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':
- if (! fatal_warnings)
- fatal_warnings = true;
- else
- warning_status = EXIT_FAILURE;
- break;
+ 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':
- hash_table_size = strtol (optarg, NULL, 10);
- if (hash_table_size == 0)
- hash_table_size = HASHMAX;
- break;
+ hash_table_size = strtol (optarg, NULL, 10);
+ if (hash_table_size == 0)
+ hash_table_size = HASHMAX;
+ break;
case 'I':
- add_include_directory (optarg);
- break;
+ add_include_directory (optarg);
+ break;
case 'L':
- nesting_limit = strtol (optarg, NULL, 10);
- break;
+ nesting_limit = strtol (optarg, NULL, 10);
+ 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':
- debug_level = debug_decode (optarg);
- if (debug_level < 0)
- {
- error (0, 0, _("bad debug flags: `%s'"), optarg);
- debug_level = 0;
- }
- break;
+ debug_level = debug_decode (optarg);
+ if (debug_level < 0)
+ {
+ error (0, 0, _("bad debug flags: `%s'"), optarg);
+ debug_level = 0;
+ }
+ break;
case 'e':
- error (0, 0, _("warning: `m4 -e' is deprecated, use `-i' instead"));
- /* fall through */
+ error (0, 0, _("warning: `m4 -e' is deprecated, use `-i' instead"));
+ /* fall through */
case 'i':
- interactive = true;
- break;
+ interactive = true;
+ break;
case 'g':
- no_gnu_extensions = 0;
- break;
+ no_gnu_extensions = 0;
+ break;
case 'l':
- max_debug_argument_length = strtol (optarg, NULL, 10);
- if (max_debug_argument_length <= 0)
- max_debug_argument_length = 0;
- break;
+ max_debug_argument_length = strtol (optarg, NULL, 10);
+ if (max_debug_argument_length <= 0)
+ max_debug_argument_length = 0;
+ break;
case 'o':
- /* -o/--error-output are deprecated synonyms of --debugfile,
- but don't issue a deprecation warning until autoconf 2.61
- or later is more widely established, as such a warning
- would interfere with all earlier versions of autoconf. */
- /* Don't call debug_set_output here, as it has side effects. */
- debugfile = optarg;
- break;
+ /* -o/--error-output are deprecated synonyms of --debugfile,
+ but don't issue a deprecation warning until autoconf 2.61
+ or later is more widely established, as such a warning
+ would interfere with all earlier versions of autoconf. */
+ /* Don't call debug_set_output here, as it has side effects. */
+ 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;
@@ -610,47 +610,47 @@ main (int argc, char *const *argv)
symbol *sym;
switch (defines->code)
- {
- case 'D':
- {
- /* defines->arg is read-only, so we need a copy. */
- char *macro_name = xstrdup (defines->arg);
- char *macro_value = strchr (macro_name, '=');
- if (macro_value)
- *macro_value++ = '\0';
- define_user_macro (macro_name, macro_value, SYMBOL_INSERT);
- free (macro_name);
- }
- break;
-
- case 'U':
- lookup_symbol (defines->arg, SYMBOL_DELETE);
- break;
-
- case 't':
- sym = lookup_symbol (defines->arg, SYMBOL_INSERT);
- SYMBOL_TRACED (sym) = true;
- break;
-
- case 's':
- sync_output = 1;
- break;
-
- case '\1':
- seen_file = true;
- process_file (defines->arg);
- break;
-
- case DEBUGFILE_OPTION:
- if (!debug_set_output (defines->arg))
- M4ERROR ((warning_status, errno, "cannot set debug file `%s'",
- debugfile ? debugfile : _("stderr")));
- break;
-
- default:
- M4ERROR ((0, 0, "INTERNAL ERROR: bad code in deferred arguments"));
- abort ();
- }
+ {
+ case 'D':
+ {
+ /* defines->arg is read-only, so we need a copy. */
+ char *macro_name = xstrdup (defines->arg);
+ char *macro_value = strchr (macro_name, '=');
+ if (macro_value)
+ *macro_value++ = '\0';
+ define_user_macro (macro_name, macro_value, SYMBOL_INSERT);
+ free (macro_name);
+ }
+ break;
+
+ case 'U':
+ lookup_symbol (defines->arg, SYMBOL_DELETE);
+ break;
+
+ case 't':
+ sym = lookup_symbol (defines->arg, SYMBOL_INSERT);
+ SYMBOL_TRACED (sym) = true;
+ break;
+
+ case 's':
+ sync_output = 1;
+ break;
+
+ case '\1':
+ seen_file = true;
+ process_file (defines->arg);
+ break;
+
+ case DEBUGFILE_OPTION:
+ if (!debug_set_output (defines->arg))
+ M4ERROR ((warning_status, errno, "cannot set debug file `%s'",
+ debugfile ? debugfile : _("stderr")));
+ break;
+
+ default:
+ M4ERROR ((0, 0, "INTERNAL ERROR: bad code in deferred arguments"));
+ abort ();
+ }
next = defines->next;
free (defines);
diff --git a/src/m4.h b/src/m4.h
index 4f524ec..c53cb1c 100644
--- a/src/m4.h
+++ b/src/m4.h
@@ -141,7 +141,7 @@ extern const char *program_name;
void m4_error (int, int, const char *, ...) M4_GNUC_PRINTF(3, 4);
void m4_error_at_line (int, int, const char *, int,
- const char *, ...) M4_GNUC_PRINTF(5, 6);
+ const char *, ...) M4_GNUC_PRINTF(5, 6);
#define M4ERROR(Arglist) (m4_error Arglist)
#define M4ERROR_AT_LINE(Arglist) (m4_error_at_line Arglist)
@@ -183,7 +183,7 @@ extern FILE *debug;
do \
{ \
if (debug != NULL) \
- xfprintf (debug, Fmt, Arg1); \
+ xfprintf (debug, Fmt, Arg1); \
} \
while (0)
@@ -191,7 +191,7 @@ extern FILE *debug;
do \
{ \
if (debug != NULL) \
- xfprintf (debug, Fmt, Arg1, Arg2, Arg3); \
+ xfprintf (debug, Fmt, Arg1, Arg2, Arg3); \
} \
while (0)
@@ -199,11 +199,11 @@ extern FILE *debug;
do \
{ \
if (debug != NULL) \
- { \
- debug_message_prefix (); \
- xfprintf (debug, Fmt); \
- putc ('\n', debug); \
- } \
+ { \
+ debug_message_prefix (); \
+ xfprintf (debug, Fmt); \
+ putc ('\n', debug); \
+ } \
} \
while (0)
@@ -211,11 +211,11 @@ extern FILE *debug;
do \
{ \
if (debug != NULL) \
- { \
- debug_message_prefix (); \
- xfprintf (debug, Fmt, Arg1); \
- putc ('\n', debug); \
- } \
+ { \
+ debug_message_prefix (); \
+ xfprintf (debug, Fmt, Arg1); \
+ putc ('\n', debug); \
+ } \
} \
while (0)
@@ -223,11 +223,11 @@ extern FILE *debug;
do \
{ \
if (debug != NULL) \
- { \
- debug_message_prefix (); \
- xfprintf (debug, Fmt, Arg1, Arg2); \
- putc ('\n', debug); \
- } \
+ { \
+ debug_message_prefix (); \
+ xfprintf (debug, Fmt, Arg1, Arg2); \
+ putc ('\n', debug); \
+ } \
} \
while (0)
@@ -270,12 +270,12 @@ struct token_data
union
{
struct
- {
- char *text;
+ {
+ char *text;
#ifdef ENABLE_CHANGEWORD
- char *original_text;
+ char *original_text;
#endif
- }
+ }
u_t;
builtin_func *func;
}
diff --git a/src/macro.c b/src/macro.c
index 04079cf..43a999f 100644
--- a/src/macro.c
+++ b/src/macro.c
@@ -96,31 +96,31 @@ expand_token (struct obstack *obs, token_type t, token_data
*td, int line)
case TOKEN_SIMPLE:
case TOKEN_STRING:
shipout_text (obs, TOKEN_DATA_TEXT (td), strlen (TOKEN_DATA_TEXT (td)),
- line);
+ line);
break;
case TOKEN_WORD:
sym = lookup_symbol (TOKEN_DATA_TEXT (td), 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
- shipout_text (obs, TOKEN_DATA_ORIG_TEXT (td),
- strlen (TOKEN_DATA_ORIG_TEXT (td)), line);
+ shipout_text (obs, TOKEN_DATA_ORIG_TEXT (td),
+ strlen (TOKEN_DATA_ORIG_TEXT (td)), line);
#else
- shipout_text (obs, TOKEN_DATA_TEXT (td),
- strlen (TOKEN_DATA_TEXT (td)), line);
+ shipout_text (obs, TOKEN_DATA_TEXT (td),
+ strlen (TOKEN_DATA_TEXT (td)), line);
#endif
- }
+ }
else
- expand_macro (sym);
+ expand_macro (sym);
break;
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad token type in expand_token ()"));
+ "INTERNAL ERROR: bad token type in expand_token ()"));
abort ();
}
}
@@ -161,59 +161,59 @@ expand_argument (struct obstack *obs, token_data *argp)
{
switch (t)
- { /* TOKSW */
- case TOKEN_COMMA:
- case TOKEN_CLOSE:
- if (paren_level == 0)
- {
- /* The argument MUST be finished, whether we want it or not. */
- obstack_1grow (obs, '\0');
- text = (char *) obstack_finish (obs);
-
- if (TOKEN_DATA_TYPE (argp) == TOKEN_VOID)
- {
- TOKEN_DATA_TYPE (argp) = TOKEN_TEXT;
- TOKEN_DATA_TEXT (argp) = text;
- }
- return t == TOKEN_COMMA;
- }
- /* fallthru */
- case TOKEN_OPEN:
- case TOKEN_SIMPLE:
- text = TOKEN_DATA_TEXT (&td);
-
- if (*text == '(')
- paren_level++;
- else if (*text == ')')
- paren_level--;
- expand_token (obs, t, &td, line);
- break;
-
- case TOKEN_EOF:
- /* current_file changed to "" if we see TOKEN_EOF, use the
- previous value we stored earlier. */
- M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, line,
- "ERROR: end of file in argument list"));
- break;
-
- case TOKEN_WORD:
- case TOKEN_STRING:
- expand_token (obs, t, &td, line);
- break;
-
- case TOKEN_MACDEF:
- if (obstack_object_size (obs) == 0)
- {
- TOKEN_DATA_TYPE (argp) = TOKEN_FUNC;
- TOKEN_DATA_FUNC (argp) = TOKEN_DATA_FUNC (&td);
- }
- break;
-
- default:
- M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad token type in expand_argument ()"));
- abort ();
- }
+ { /* TOKSW */
+ case TOKEN_COMMA:
+ case TOKEN_CLOSE:
+ if (paren_level == 0)
+ {
+ /* The argument MUST be finished, whether we want it or not. */
+ obstack_1grow (obs, '\0');
+ text = (char *) obstack_finish (obs);
+
+ if (TOKEN_DATA_TYPE (argp) == TOKEN_VOID)
+ {
+ TOKEN_DATA_TYPE (argp) = TOKEN_TEXT;
+ TOKEN_DATA_TEXT (argp) = text;
+ }
+ return t == TOKEN_COMMA;
+ }
+ /* fallthru */
+ case TOKEN_OPEN:
+ case TOKEN_SIMPLE:
+ text = TOKEN_DATA_TEXT (&td);
+
+ if (*text == '(')
+ paren_level++;
+ else if (*text == ')')
+ paren_level--;
+ expand_token (obs, t, &td, line);
+ break;
+
+ case TOKEN_EOF:
+ /* current_file changed to "" if we see TOKEN_EOF, use the
+ previous value we stored earlier. */
+ M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, line,
+ "ERROR: end of file in argument list"));
+ break;
+
+ case TOKEN_WORD:
+ case TOKEN_STRING:
+ expand_token (obs, t, &td, line);
+ break;
+
+ case TOKEN_MACDEF:
+ if (obstack_object_size (obs) == 0)
+ {
+ TOKEN_DATA_TYPE (argp) = TOKEN_FUNC;
+ TOKEN_DATA_FUNC (argp) = TOKEN_DATA_FUNC (&td);
+ }
+ break;
+
+ default:
+ M4ERROR ((warning_status, 0,
+ "INTERNAL ERROR: bad token type in expand_argument ()"));
+ abort ();
+ }
t = next_token (&td, NULL);
}
@@ -227,7 +227,7 @@ expand_argument (struct obstack *obs, token_data *argp)
static void
collect_arguments (symbol *sym, struct obstack *argptr,
- struct obstack *arguments)
+ struct obstack *arguments)
{
token_data td;
token_data *tdp;
@@ -243,17 +243,17 @@ collect_arguments (symbol *sym, struct obstack *argptr,
{
next_token (&td, NULL); /* gobble parenthesis */
do
- {
- more_args = expand_argument (arguments, &td);
-
- if (!groks_macro_args && TOKEN_DATA_TYPE (&td) == TOKEN_FUNC)
- {
- TOKEN_DATA_TYPE (&td) = TOKEN_TEXT;
- TOKEN_DATA_TEXT (&td) = (char *) "";
- }
- tdp = (token_data *) obstack_copy (arguments, &td, sizeof td);
- obstack_ptr_grow (argptr, tdp);
- }
+ {
+ more_args = expand_argument (arguments, &td);
+
+ if (!groks_macro_args && TOKEN_DATA_TYPE (&td) == TOKEN_FUNC)
+ {
+ TOKEN_DATA_TYPE (&td) = TOKEN_TEXT;
+ TOKEN_DATA_TEXT (&td) = (char *) "";
+ }
+ tdp = (token_data *) obstack_copy (arguments, &td, sizeof td);
+ obstack_ptr_grow (argptr, tdp);
+ }
while (more_args);
}
}
@@ -270,7 +270,7 @@ collect_arguments (symbol *sym, struct obstack *argptr,
void
call_macro (symbol *sym, int argc, token_data **argv,
- struct obstack *expansion)
+ struct obstack *expansion)
{
switch (SYMBOL_TYPE (sym))
{
@@ -285,7 +285,7 @@ call_macro (symbol *sym, int argc, token_data **argv,
case TOKEN_VOID:
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: bad symbol type in call_macro ()"));
+ "INTERNAL ERROR: bad symbol type in call_macro ()"));
abort ();
}
}
@@ -328,8 +328,8 @@ expand_macro (symbol *sym)
expansion_level++;
if (nesting_limit > 0 && expansion_level > nesting_limit)
M4ERROR ((EXIT_FAILURE, 0,
- "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));
macro_call_id++;
my_call_id = macro_call_id;
@@ -340,8 +340,8 @@ expand_macro (symbol *sym)
if (obstack_object_size (&argc_stack) > 0)
{
/* We cannot use argc_stack if this is a nested invocation, and an
- outer invocation has an unfinished argument being
- collected. */
+ outer invocation has an unfinished argument being
+ collected. */
obstack_init (&arguments);
use_argc_stack = false;
}
@@ -350,10 +350,10 @@ expand_macro (symbol *sym)
trace_prepre (SYMBOL_NAME (sym), my_call_id);
collect_arguments (sym, &argv_stack,
- use_argc_stack ? &argc_stack : &arguments);
+ use_argc_stack ? &argc_stack : &arguments);
argc = ((obstack_object_size (&argv_stack) - argv_base)
- / sizeof (token_data *));
+ / sizeof (token_data *));
argv = (token_data **) ((char *) obstack_base (&argv_stack) + argv_base);
loc_close_file = current_file;
diff --git a/src/output.c b/src/output.c
index 4070baa..65af2eb 100644
--- a/src/output.c
+++ b/src/output.c
@@ -25,6 +25,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. */
@@ -58,9 +59,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. */
@@ -162,16 +163,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)
- {
- M4ERROR ((0, errno,
- "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)
+ {
+ M4ERROR ((0, errno,
+ "cannot clean temporary file for diversion"));
+ fail = true;
+ }
+ }
gl_oset_iterator_free (&iter);
}
@@ -192,7 +193,7 @@ m4_tmpname (int divnum)
{
tail = xasprintf ("%s/m4-%d", output_temp_dir->dir_name, INT_MAX);
buffer = (char *) obstack_copy0 (&diversion_storage, tail,
- strlen (tail));
+ strlen (tail));
free (tail);
tail = strrchr (buffer, '-') + 1;
}
@@ -218,8 +219,8 @@ m4_tmpfile (int divnum)
{
output_temp_dir = create_temp_dir ("m4-", NULL, true);
if (output_temp_dir == NULL)
- M4ERROR ((EXIT_FAILURE, errno,
- "cannot create temporary file for diversion"));
+ M4ERROR ((EXIT_FAILURE, errno,
+ "cannot create temporary file for diversion"));
atexit (cleanup_tmpfile);
}
name = m4_tmpname (divnum);
@@ -229,11 +230,11 @@ m4_tmpfile (int divnum)
{
unregister_temp_file (output_temp_dir, name);
M4ERROR ((EXIT_FAILURE, errno,
- "cannot create temporary file for diversion"));
+ "cannot create temporary file for diversion"));
}
else if (set_cloexec_flag (fileno (file), true) != 0)
M4ERROR ((warning_status, errno,
- "Warning: cannot protect diversion across forks"));
+ "Warning: cannot protect diversion across forks"));
return file;
}
@@ -251,16 +252,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,
- _("cannot seek within diversion"));
+ m4_error (EXIT_FAILURE, errno,
+ _("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,
- _("cannot seek within diversion"));
+ m4_error (EXIT_FAILURE, errno,
+ _("cannot seek within diversion"));
tmp_file2_recent = true;
return tmp_file2;
}
@@ -269,14 +270,14 @@ m4_tmpopen (int divnum, bool reread)
file = fopen_temp (name, O_BINARY ? "rb+" : "r+");
if (file == NULL)
M4ERROR ((EXIT_FAILURE, errno,
- "cannot create temporary file for diversion"));
+ "cannot create temporary file for diversion"));
else if (set_cloexec_flag (fileno (file), true) != 0)
m4_error (0, errno, _("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,
- _("cannot seek within diversion"));
+ _("cannot seek within diversion"));
return file;
}
@@ -292,19 +293,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;
}
@@ -317,14 +318,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));
@@ -344,33 +345,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,
- _("cannot close temporary file for diversion"));
- tmp_file1_owner = 0;
- }
+ {
+ if (close_stream_temp (tmp_file1))
+ m4_error (EXIT_FAILURE, errno,
+ _("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,
- _("cannot close temporary file for diversion"));
- tmp_file2_owner = 0;
- }
+ {
+ if (close_stream_temp (tmp_file2))
+ m4_error (EXIT_FAILURE, errno,
+ _("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,
- _("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);
@@ -385,7 +386,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;
@@ -446,30 +447,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;
@@ -478,13 +479,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)
- M4ERROR ((EXIT_FAILURE, errno,
- "ERROR: cannot flush diversion to temporary file"));
- }
+ {
+ count = fwrite (selected_buffer, (size_t) selected_diversion->used,
+ 1, selected_diversion->u.file);
+ if (count != 1)
+ M4ERROR ((EXIT_FAILURE, errno,
+ "ERROR: cannot flush diversion to temporary file"));
+ }
/* Reclaim the buffer space for other diversions. */
@@ -506,20 +507,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_error (0, errno,
- _("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_error (0, errno,
+ _("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;
@@ -577,7 +578,7 @@ output_text (const char *text, int length)
{
count = fwrite (text, length, 1, output_file);
if (count != 1)
- M4ERROR ((EXIT_FAILURE, errno, "ERROR: copying inserted file"));
+ M4ERROR ((EXIT_FAILURE, errno, "ERROR: copying inserted file"));
}
else
{
@@ -627,7 +628,7 @@ shipout_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++;
@@ -638,71 +639,71 @@ shipout_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)
- {
- OUTPUT_CHARACTER ('#');
- OUTPUT_CHARACTER ('l');
- OUTPUT_CHARACTER ('i');
- OUTPUT_CHARACTER ('n');
- OUTPUT_CHARACTER ('e');
- OUTPUT_CHARACTER (' ');
- for (cursor = ntoa (line, 10); *cursor; cursor++)
- OUTPUT_CHARACTER (*cursor);
- if (output_current_line < 1 && current_file[0] != '\0')
- {
- OUTPUT_CHARACTER (' ');
- OUTPUT_CHARACTER ('"');
- for (cursor = current_file; *cursor; cursor++)
- OUTPUT_CHARACTER (*cursor);
- 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)
+ {
+ OUTPUT_CHARACTER ('#');
+ OUTPUT_CHARACTER ('l');
+ OUTPUT_CHARACTER ('i');
+ OUTPUT_CHARACTER ('n');
+ OUTPUT_CHARACTER ('e');
+ OUTPUT_CHARACTER (' ');
+ for (cursor = ntoa (line, 10); *cursor; cursor++)
+ OUTPUT_CHARACTER (*cursor);
+ if (output_current_line < 1 && current_file[0] != '\0')
+ {
+ OUTPUT_CHARACTER (' ');
+ OUTPUT_CHARACTER ('"');
+ for (cursor = current_file; *cursor; cursor++)
+ OUTPUT_CHARACTER (*cursor);
+ 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;
+ }
}
}
@@ -727,23 +728,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_error (0, errno,
- _("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_error (0, errno,
+ _("cannot close temporary file for diversion"));
+ }
output_diversion = NULL;
output_file = NULL;
output_cursor = NULL;
@@ -761,28 +762,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);
@@ -797,8 +798,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;
@@ -825,9 +826,9 @@ insert_file (FILE *file)
{
length = fread (buffer, 1, sizeof buffer, file);
if (ferror (file))
- M4ERROR ((EXIT_FAILURE, errno, "error reading inserted file"));
+ M4ERROR ((EXIT_FAILURE, errno, "error reading inserted file"));
if (length == 0)
- break;
+ break;
output_text (buffer, length);
}
}
@@ -846,47 +847,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;
}
@@ -895,22 +896,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_error (0, errno,
- _("cannot clean temporary file for diversion"));
- }
+ {
+ FILE *file = diversion->u.file;
+ diversion->u.file = NULL;
+ if (m4_tmpclose (file, diversion->divnum) != 0)
+ m4_error (0, errno,
+ _("cannot clean temporary file for diversion"));
+ }
if (m4_tmpremove (diversion->divnum) != 0)
- M4ERROR ((0, errno, "cannot clean temporary file for diversion"));
+ M4ERROR ((0, errno, "cannot clean temporary file for diversion"));
}
diversion->used = 0;
gl_oset_remove (diversion_table, diversion);
@@ -934,11 +935,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);
}
}
@@ -956,7 +957,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);
}
@@ -983,28 +984,28 @@ 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)
- M4ERROR ((EXIT_FAILURE, errno, "cannot stat diversion"));
- if (file_stat.st_size < 0
- || (file_stat.st_size + 0UL
- != (unsigned long int) file_stat.st_size))
- M4ERROR ((EXIT_FAILURE, 0, "diversion too large"));
- xfprintf (file, "D%d,%lu\n", 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)
+ M4ERROR ((EXIT_FAILURE, errno, "cannot stat diversion"));
+ if (file_stat.st_size < 0
+ || (file_stat.st_size + 0UL
+ != (unsigned long int) file_stat.st_size))
+ M4ERROR ((EXIT_FAILURE, 0, "diversion too large"));
+ xfprintf (file, "D%d,%lu\n", 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 49e624e..d10752e 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,14 +116,14 @@ 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)
- M4ERROR ((warning_status, errno,
- "Warning: cannot protect input file across forks"));
+ M4ERROR ((warning_status, errno,
+ "Warning: cannot protect input file across forks"));
}
return fp;
}
@@ -156,7 +156,7 @@ m4_path_search (const char *file, char **result)
if (fp != NULL)
{
if (result)
- *result = xstrdup (file);
+ *result = xstrdup (file);
return fp;
}
@@ -175,15 +175,15 @@ m4_path_search (const char *file, char **result)
fp = m4_fopen (name);
if (fp != NULL)
- {
- if (debug_level & DEBUG_TRACE_PATH)
- DEBUG_MESSAGE2 ("path search for `%s' found `%s'", file, name);
- if (result)
- *result = name;
- else
- free (name);
- return fp;
- }
+ {
+ if (debug_level & DEBUG_TRACE_PATH)
+ DEBUG_MESSAGE2 ("path search for `%s' found `%s'", file, name);
+ if (result)
+ *result = name;
+ else
+ free (name);
+ return fp;
+ }
free (name);
}
errno = e;
diff --git a/src/symtab.c b/src/symtab.c
index eb37872..e0ee93d 100644
--- a/src/symtab.c
+++ b/src/symtab.c
@@ -57,9 +57,9 @@ show_profile (void)
for (i = 0; i < 5; i++)
{
xfprintf(stderr, "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);
}
}
@@ -111,7 +111,7 @@ symtab_init (void)
int e = atexit(show_profile);
if (e != 0)
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: unable to show symtab profile"));
+ "INTERNAL ERROR: unable to show symtab profile"));
}
#endif /* DEBUG_SYM */
}
@@ -146,7 +146,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);
}
}
@@ -184,7 +184,7 @@ lookup_symbol (const char *name, symbol_lookup mode)
{
cmp = strcmp (SYMBOL_NAME (sym), name);
if (cmp >= 0)
- break;
+ break;
}
/* If just searching, return status of search. */
@@ -202,40 +202,40 @@ lookup_symbol (const char *name, 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 (cmp == 0 && sym != NULL)
- {
- if (SYMBOL_PENDING_EXPANSIONS (sym) > 0)
- {
- symbol *old = sym;
- SYMBOL_DELETED (old) = true;
-
- sym = (symbol *) xmalloc (sizeof (symbol));
- SYMBOL_TYPE (sym) = TOKEN_VOID;
- SYMBOL_TRACED (sym) = SYMBOL_TRACED (old);
- SYMBOL_NAME (sym) = xstrdup (name);
- SYMBOL_SHADOWED (sym) = false;
- SYMBOL_MACRO_ARGS (sym) = false;
- SYMBOL_BLIND_NO_ARGS (sym) = false;
- SYMBOL_DELETED (sym) = false;
- SYMBOL_PENDING_EXPANSIONS (sym) = 0;
-
- SYMBOL_NEXT (sym) = SYMBOL_NEXT (old);
- SYMBOL_NEXT (old) = NULL;
- (*spp) = sym;
- }
- return sym;
- }
+ {
+ if (SYMBOL_PENDING_EXPANSIONS (sym) > 0)
+ {
+ symbol *old = sym;
+ SYMBOL_DELETED (old) = true;
+
+ sym = (symbol *) xmalloc (sizeof (symbol));
+ SYMBOL_TYPE (sym) = TOKEN_VOID;
+ SYMBOL_TRACED (sym) = SYMBOL_TRACED (old);
+ SYMBOL_NAME (sym) = xstrdup (name);
+ SYMBOL_SHADOWED (sym) = false;
+ SYMBOL_MACRO_ARGS (sym) = false;
+ SYMBOL_BLIND_NO_ARGS (sym) = false;
+ SYMBOL_DELETED (sym) = false;
+ SYMBOL_PENDING_EXPANSIONS (sym) = 0;
+
+ SYMBOL_NEXT (sym) = SYMBOL_NEXT (old);
+ SYMBOL_NEXT (old) = NULL;
+ (*spp) = sym;
+ }
+ return sym;
+ }
/* Fall through. */
case SYMBOL_PUSHDEF:
/* Insert a name in the symbol table. If there is already a symbol
- with the name, insert this in front of it, and mark the old
- symbol as "shadowed". */
+ with the name, insert this in front of it, and mark the old
+ symbol as "shadowed". */
sym = (symbol *) xmalloc (sizeof (symbol));
SYMBOL_TYPE (sym) = TOKEN_VOID;
@@ -251,65 +251,65 @@ lookup_symbol (const char *name, symbol_lookup mode)
(*spp) = sym;
if (mode == SYMBOL_PUSHDEF && cmp == 0)
- {
- SYMBOL_SHADOWED (SYMBOL_NEXT (sym)) = true;
- SYMBOL_TRACED (sym) = SYMBOL_TRACED (SYMBOL_NEXT (sym));
- }
+ {
+ SYMBOL_SHADOWED (SYMBOL_NEXT (sym)) = true;
+ SYMBOL_TRACED (sym) = SYMBOL_TRACED (SYMBOL_NEXT (sym));
+ }
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 (cmp != 0 || sym == NULL)
- return NULL;
+ return NULL;
{
- bool traced = false;
- if (SYMBOL_NEXT (sym) != NULL
- && SYMBOL_SHADOWED (SYMBOL_NEXT (sym))
- && mode == SYMBOL_POPDEF)
- {
- SYMBOL_SHADOWED (SYMBOL_NEXT (sym)) = false;
- SYMBOL_TRACED (SYMBOL_NEXT (sym)) = SYMBOL_TRACED (sym);
- }
- else
- traced = SYMBOL_TRACED (sym);
- do
- {
- *spp = SYMBOL_NEXT (sym);
- free_symbol (sym);
- sym = *spp;
- }
- while (*spp != NULL && SYMBOL_SHADOWED (*spp)
- && mode == SYMBOL_DELETE);
- if (traced)
- {
- sym = (symbol *) xmalloc (sizeof (symbol));
- SYMBOL_TYPE (sym) = TOKEN_VOID;
- SYMBOL_TRACED (sym) = true;
- SYMBOL_NAME (sym) = xstrdup (name);
- SYMBOL_SHADOWED (sym) = false;
- SYMBOL_MACRO_ARGS (sym) = false;
- SYMBOL_BLIND_NO_ARGS (sym) = false;
- SYMBOL_DELETED (sym) = false;
- SYMBOL_PENDING_EXPANSIONS (sym) = 0;
-
- SYMBOL_NEXT (sym) = *spp;
- (*spp) = sym;
- }
+ bool traced = false;
+ if (SYMBOL_NEXT (sym) != NULL
+ && SYMBOL_SHADOWED (SYMBOL_NEXT (sym))
+ && mode == SYMBOL_POPDEF)
+ {
+ SYMBOL_SHADOWED (SYMBOL_NEXT (sym)) = false;
+ SYMBOL_TRACED (SYMBOL_NEXT (sym)) = SYMBOL_TRACED (sym);
+ }
+ else
+ traced = SYMBOL_TRACED (sym);
+ do
+ {
+ *spp = SYMBOL_NEXT (sym);
+ free_symbol (sym);
+ sym = *spp;
+ }
+ while (*spp != NULL && SYMBOL_SHADOWED (*spp)
+ && mode == SYMBOL_DELETE);
+ if (traced)
+ {
+ sym = (symbol *) xmalloc (sizeof (symbol));
+ SYMBOL_TYPE (sym) = TOKEN_VOID;
+ SYMBOL_TRACED (sym) = true;
+ SYMBOL_NAME (sym) = xstrdup (name);
+ SYMBOL_SHADOWED (sym) = false;
+ SYMBOL_MACRO_ARGS (sym) = false;
+ SYMBOL_BLIND_NO_ARGS (sym) = false;
+ SYMBOL_DELETED (sym) = false;
+ SYMBOL_PENDING_EXPANSIONS (sym) = 0;
+
+ SYMBOL_NEXT (sym) = *spp;
+ (*spp) = sym;
+ }
}
return NULL;
case SYMBOL_LOOKUP:
default:
M4ERROR ((warning_status, 0,
- "INTERNAL ERROR: invalid mode to symbol_lookup ()"));
+ "INTERNAL ERROR: invalid mode to symbol_lookup ()"));
abort ();
}
}
@@ -335,13 +335,13 @@ hack_all_symbols (hack_symbol *func, void *data)
for (h = 0; h < hash_table_size; h++)
{
/* 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. */
for (sym = symtab[h]; sym != NULL; sym = next)
- {
- next = SYMBOL_NEXT (sym);
- func (sym, data);
- }
+ {
+ next = SYMBOL_NEXT (sym);
+ func (sym, data);
+ }
}
}
@@ -362,22 +362,22 @@ symtab_debug (void)
{
text = TOKEN_DATA_TEXT (&td);
if (*text == '_')
- {
- delete = 1;
- text++;
- }
+ {
+ delete = 1;
+ text++;
+ }
else
- delete = 0;
+ delete = 0;
s = lookup_symbol (text, SYMBOL_LOOKUP);
if (s == NULL)
- xprintf ("Name `%s' is unknown\n", text);
+ xprintf ("Name `%s' is unknown\n", text);
if (delete)
- (void) lookup_symbol (text, SYMBOL_DELETE);
+ (void) lookup_symbol (text, SYMBOL_DELETE);
else
- (void) lookup_symbol (text, SYMBOL_INSERT);
+ (void) lookup_symbol (text, SYMBOL_INSERT);
}
symtab_print_list (i++);
}
@@ -392,13 +392,13 @@ symtab_print_list (int i)
for (h = 0; h < hash_table_size; h++)
for (sym = symtab[h]; sym != NULL; sym = sym->next)
xprintf ("\tname %s, bucket %lu, addr %p, next %p, "
- "flags%s%s%s, pending %d\n",
- SYMBOL_NAME (sym),
- (unsigned long int) h, sym, SYMBOL_NEXT (sym),
- SYMBOL_TRACED (sym) ? " traced" : "",
- SYMBOL_SHADOWED (sym) ? " shadowed" : "",
- SYMBOL_DELETED (sym) ? " deleted" : "",
- SYMBOL_PENDING_EXPANSIONS (sym));
+ "flags%s%s%s, pending %d\n",
+ SYMBOL_NAME (sym),
+ (unsigned long int) h, sym, SYMBOL_NEXT (sym),
+ SYMBOL_TRACED (sym) ? " traced" : "",
+ SYMBOL_SHADOWED (sym) ? " shadowed" : "",
+ SYMBOL_DELETED (sym) ? " deleted" : "",
+ SYMBOL_PENDING_EXPANSIONS (sym));
}
#endif /* DEBUG_SYM */
hooks/post-receive
--
GNU M4 source repository
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [SCM] GNU M4 source repository branch, branch-1.4, updated. v1.4.13-26-ga8cef71,
Eric Blake <=