[COMMIT] Add a byte-compile method for #'ignore, chiefly for generated code
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524863122 -3600
# Fri Apr 27 22:05:22 2018 +0100
# Node ID 8a7f058930de4b49190ad1381cba59dbfc93483d
# Parent fd1fdfb2c336c61478e7a2ca0cd98ebab06a54d9
Add a byte-compile method for #'ignore, chiefly for generated code
lisp/ChangeLog addition:
2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp.el:
* bytecomp.el (ignore):
* bytecomp.el (byte-compile-ignore): New.
Add a byte-compile method for #'ignore, marking all its arguments
as for-effect, and returning nil.
tests/ChangeLog addition:
2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
* automated/lisp-tests.el:
* automated/lisp-tests.el (null):
Test #'ignore and its newly-added byte-compile method.
diff -r fd1fdfb2c336 -r 8a7f058930de lisp/ChangeLog
--- a/lisp/ChangeLog Fri Apr 27 12:50:19 2018 +0100
+++ b/lisp/ChangeLog Fri Apr 27 22:05:22 2018 +0100
＠＠ -1,3 +1,11 ＠＠
+2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * bytecomp.el:
+ * bytecomp.el (ignore):
+ * bytecomp.el (byte-compile-ignore): New.
+ Add a byte-compile method for #'ignore, marking all its arguments
+ as for-effect, and returning nil.
+
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* subr.el (not): New.
diff -r fd1fdfb2c336 -r 8a7f058930de lisp/bytecomp.el
--- a/lisp/bytecomp.el Fri Apr 27 12:50:19 2018 +0100
+++ b/lisp/bytecomp.el Fri Apr 27 22:05:22 2018 +0100
＠＠ -4661,6 +4661,8 ＠＠
(byte-defop-compiler-1 defalias)
(byte-defop-compiler-1 define-function)
+(byte-defop-compiler-1 ignore)
+
(defun byte-compile-defun (form)
;; This is not used for file-level defuns with doc strings.
(byte-compile-two-args ; Use this to avoid byte-compile-fset's warning.
＠＠ -4772,6 +4774,10 ＠＠
(if calls
(setq byte-compile-unresolved-functions
(delete* calls byte-compile-unresolved-functions)))))
+
+(defun byte-compile-ignore (form)
+ (mapc #'byte-compile-form (cdr form) '#1=(t . #1#))
+ (unless for-effect (byte-compile-push-constant nil)))
;;; tags
diff -r fd1fdfb2c336 -r 8a7f058930de tests/ChangeLog
--- a/tests/ChangeLog Fri Apr 27 12:50:19 2018 +0100
+++ b/tests/ChangeLog Fri Apr 27 22:05:22 2018 +0100
＠＠ -1,3 +1,9 ＠＠
+2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * automated/lisp-tests.el:
+ * automated/lisp-tests.el (null):
+ Test #'ignore and its newly-added byte-compile method.
+
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* automated/lisp-tests.el:
diff -r fd1fdfb2c336 -r 8a7f058930de tests/automated/lisp-tests.el
--- a/tests/automated/lisp-tests.el Fri Apr 27 12:50:19 2018 +0100
+++ b/tests/automated/lisp-tests.el Fri Apr 27 22:05:22 2018 +0100
＠＠ -3265,6 +3265,13 ＠＠
(Assert (not (funcall (intern "eq") #'bookend #'refer-to-bookend))
"checking two mutually recursive functions compiled OK"))))
+(Assert (null (ignore)) "checking ignore gives nil, no arguments")
+(Assert (null (ignore 40 90.5 pi))
+ "checking ignore gives nil, three arguments")
+(let (value)
+ (Assert (eq 'hi (prog2 (ignore (setq value 'hi)) value))
+ "checking side-effecting statements not deleted, ignore"))
+
;; Test macroexpand's handling of the ENVIRONMENT argument. We augmented it
;; quietly for about four months, and this was incorrect.
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Remove lib-src/make-case-conv.py definitively.
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524829819 -3600
# Fri Apr 27 12:50:19 2018 +0100
# Node ID fd1fdfb2c336c61478e7a2ca0cd98ebab06a54d9
# Parent 06e4b596dc40844bb53645fbf12cffa40d7922a7
Remove lib-src/make-case-conv.py definitively.
lib-src/ChangeLog addition:
2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
* make-case-conv.py:
Remove this file, replaced by lisp/mule/make-case-conv.el
diff -r 06e4b596dc40 -r fd1fdfb2c336 lib-src/ChangeLog
--- a/lib-src/ChangeLog Wed Apr 25 21:49:16 2018 +0100
+++ b/lib-src/ChangeLog Fri Apr 27 12:50:19 2018 +0100
＠＠ -1,3 +1,8 ＠＠
+2018-04-27 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * make-case-conv.py:
+ Remove this file, replaced by lisp/mule/make-case-conv.el
+
2017-11-09 Aidan Kehoe <kehoea(a)parhasard.net>
* make-case-conv.py:
diff -r 06e4b596dc40 -r fd1fdfb2c336 lib-src/make-case-conv.py
--- a/lib-src/make-case-conv.py Wed Apr 25 21:49:16 2018 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
＠＠ -1,208 +0,0 ＠＠
-#!/usr/bin/python
-
-### make-case-conv.py --- generate case-conversion info from the Unicode database
-
-## Copyright (C) 2010 Ben Wing.
-
-## Author: Ben Wing <ben(a)xemacs.org>
-## Maintainer: Ben Wing <ben(a)xemacs.org>
-## Current Version: 1.0, January 25, 2010
-
-## This file is part of XEmacs.
-
-## XEmacs is free software; you can redistribute it and/or modify it
-## under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2, or (at your option)
-## any later version.
-
-## XEmacs is distributed in the hope that it will be useful, but
-## WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-## General Public License for more details.
-
-## You should have received a copy of the GNU General Public License
-## along with XEmacs; see the file COPYING. If not, write to the Free
-## Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-## 02111-1307, USA.
-
-### Commentary:
-
-# This file parses the file CaseFolding.txt in Unicode's UNIDATA package,
-# and generates a Lisp file containing instructions to set all the case
-# mappings in the standard case table.
-
-# To run this file, redirect its stdout to the file mule/uni-case-conv.el
-# (or whatever else you have named it according to the variable
-# `output_filename').
-
-# #### Aidan Kehoe, Do 9 Nov 2017 21:32:14 GMT; this approach doesn't work,
-# since CaseFolding folds both upper and lower case characters to lower case,
-# without marking which is which. We need to parse UnicodeData.txt instead; I
-# do this in lisp/mule/make-case-conv.el. I will remove make-case-conv.py down
-# the line.
-
-### Code:
-
-import urllib2, re, sys
-#import fileinput
-
-# The URL holding the case-folding table at www.unicode.org.
-uni_casefold_url = 'http://www.unicode.org/Public/UNIDATA/CaseFolding.txt'
-
-# Path to this file, as will appear in the comments of the generated file
-our_filepath = 'lib-src/make-case-conv.py'
-
-# Name of the generated file (no directories in it)
-output_filename = 'uni-case-conv.el'
-
-def argformat(format, arg):
- if type(format) is str:
- return format % arg
- else:
- return str(format)
-
-# Write formatted arguments to stdout.
-def outout(format, *arg):
- sys.stdout.write(argformat(format, arg))
-
-# Write formatted arguments to stderr.
-def errout(format, *arg):
- sys.stderr.write(argformat(format, arg))
-
-
-
-print """\
-;;; %s --- Case-conversion support for Unicode
-
-;; Copyright (C) 2010 Ben Wing.
-
-;; Keywords: multilingual, case, uppercase, lowercase, Unicode
-
-;; This file is part of XEmacs.
-
-;; XEmacs is free software; you can redistribute it and/or modify it
-;; under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; XEmacs is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with XEmacs; see the file COPYING. If not, write to the Free
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-;; 02111-1307, USA.
-
-;;; Commentary:
-
-;; DO NOT MODIFY THIS FILE!!!!!!!!!!!!!!!!
-;; This file is autogenerated by %s. Modify that
-;; file instead.
-
-;;; Code:
-
-;; Hack: We nreverse the table below before applying it so that the more
-;; desirable mappings, which come early, override less desirable later ones.
-;; In particular, we definitely do not want the following bindings to work
-;; both ways:
-
-;; (?\u017F ?\u0073) ;; LATIN SMALL LETTER LONG S
-;; (?\u212A ?\u006B) ;; KELVIN SIGN
-;; (?\u212B ?\u00E5) ;; ANGSTROM SIGN
-
-;; The first two are especially bad as they will cause upcasing operations
-;; on lowercase s and k to give strange results. It's actually worse than
-;; that -- for unknown reasons, with the bad mappings in place, the byte-
-;; compiler produces broken code for some files, which results in a stack-
-;; underflow crash upon loadup in preparation for dumping.
-
-(loop
- for (upper lower)
- in (nreverse
- '(
-""" % (output_filename, our_filepath),
-
-#for line in fileinput.input():
-for line in urllib2.urlopen(uni_casefold_url):
-
- # Save original line
- saveline = line
-
- # Save comment then remove it
- m = re.match(r'.*#\s*(.*)', line)
- if m:
- comment = m.group(1)
- else:
- comment = ''
- line = re.sub('#.*', '', line)
-
- # Strip whitespace; if line blank, do next one
- line = line.strip()
- if not line:
- continue
-
- if re.match(r'([0-9A-F]+); F; (([0-9A-F]+)( [0-9A-F]+)*);$', line):
- errout("Warning: Can't handle full mapping: %s", saveline)
- outout(";;; WARNING: Unhandled full mapping:\n;;; %s", saveline)
- continue
- if re.match(r'([0-9A-F]+); T; ([0-9A-F]+);$', line):
- errout("Warning: Can't handle Turkish mapping: %s", saveline)
- outout(";;; WARNING: Unhandled Turkish mapping:\n;;; %s",
- saveline)
- continue
- m = re.match(r'([0-9A-F]+); [CS]; ([0-9A-F]+);$', line)
- if not m:
- errout("Warning: Unrecognized line: %s", saveline)
- outout(";;; WARNING: Unrecognized line:\n;;; %s", saveline)
- continue
-
- def tounichar(val):
- if val <= 0xFFFF:
- return r'?\u%04X' % val
- else:
- return r'?\U%08X' % val
- upper = tounichar(int(m.group(1), 16))
- lower = tounichar(int(m.group(2), 16))
- print r' (%s %s) ;; %s' % (upper, lower, comment)
-
-print """\
- ))
- with case-table = (standard-case-table)
- do
- (put-case-table-pair upper lower case-table))
-
-(provide '%s)
-
-;;; %s ends here""" % (output_filename.replace(".el",""), output_filename)
-
-## Another version, trying to diagnose byte-compiler underflow error caused
-## by these additions
-#print """\
-# )
-# with case-table = (standard-case-table)
-# do
-# (let* ((existing-lower (get-case-table 'downcase upper case-table))
-# (existing-lower (and (not (eq existing-lower upper)) existing-lower)))
-# ;;(when (not (eq (char-charset lower) (char-charset upper)))
-# ;; (princ (format "Upper %s (%s) not same charset as lower %s (%s)" upper (char-charset upper) lower (char-charset lower))))
-# (cond ((eq existing-lower lower)
-# ;;(princ (format "Already seen mapping %s for char %s" lower upper))
-# )
-# (existing-lower
-# ;;(princ (format "Existing mapping for char %s is %s, different from new %s?" upper existing-lower lower))
-# )
-# ((and (not (featurep 'unicode-internal))
-# (not (eq (char-charset lower) (char-charset upper))))
-# ;;(princ (format "Not adding cross-charset mapping %s -> %s" upper lower))
-# )
-# (t
-# ;;(princ (format "Adding mapping for upper %s -> lower %s" upper lower))
-# (put-case-table-pair upper lower case-table)
-# ))))
-#"""
-#print """\
-#(provide '%s)
-#
-#;;; %s ends here""" % (output_filename.replace(".el",""), output_filename)
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Move further trivial predicates from data.c to subr.el
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524689356 -3600
# Wed Apr 25 21:49:16 2018 +0100
# Node ID 06e4b596dc40844bb53645fbf12cffa40d7922a7
# Parent 262dc5a418f5aed7f0284e8d63e39ba6a529166c
Move further trivial predicates from data.c to subr.el
lisp/ChangeLog addition:
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* subr.el (not): New.
* subr.el (null): New.
* subr.el (atom): New.
* subr.el (listp): New.
* subr.el (nlistp): New.
* subr.el (bitp): New.
* subr.el (zerop): New.
* subr.el (true-list-p): New.
Move all these functions from C, they're not loop hotspots,
they're easily implemented in Lisp, and implementing them in C
costs less memory with NEWGC.
* bytecomp.el (byte-compile-throw):
#'null is no longer in C, don't include its code in
byte-compile-checks-on-load.
* dumped-lisp.el:
* dumped-lisp.el (preloaded-file-list):
* loadup.el (gc-cons-threshold):
* loadup.el (really-early-error-handler):
* loadup.el (fboundp):
* make-docfile.el (done):
* make-docfile.el (process-args):
* make-docfile.el (preloaded-file-list):
* make-docfile.el (site-file-list):
* packages.el (packages-add-suffix):
* packages.el (packages-list-autoloads-path):
* update-elc.el:
* update-elc.el (preloaded-file-list):
* update-elc.el (or):
* update-elc.el (featurep):
* update-elc.el (do-autoload-commands):
Don't use those functions when running a bare-metal XEmacs binary.
src/ChangeLog addition:
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* data.c (Fatom, Flistp, Fnlistp, Fbitp, Fzerop, Ftrue_list_p):
Move all these functions to Lisp, since they are easily
implemented in Lisp, and having them in C necessitates extra space
in the dumped executable with NEWGC.
* data.c (Flistp):
* data.c (syms_of_data):
Remove various DEFSUBRs from here.
* data.c (Fnonnegativep):
Document that this returns t if OBJECT is a nonnegative rational,
rather than a number in general.
* data.c (Fnumberp):
Document that this returns t if OBJECT is a floating point or a
rational, rather than just an integer.
* data.c:
* lisp.h:
* tooltalk.c (tooltalk_message_callback):
Use Ffunctionp() here rather than re-implementing it.
tests/ChangeLog addition:
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* automated/lisp-tests.el:
Test various of the simple predicates just moved to subr.el from
data.c.
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/ChangeLog
--- a/lisp/ChangeLog Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/ChangeLog Wed Apr 25 21:49:16 2018 +0100
＠＠ -1,3 +1,37 ＠＠
+2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * subr.el (not): New.
+ * subr.el (null): New.
+ * subr.el (atom): New.
+ * subr.el (listp): New.
+ * subr.el (nlistp): New.
+ * subr.el (bitp): New.
+ * subr.el (zerop): New.
+ * subr.el (true-list-p): New.
+ Move all these functions from C, they're not loop hotspots,
+ they're easily implemented in Lisp, and implementing them in C
+ costs less memory with NEWGC.
+ * bytecomp.el (byte-compile-throw):
+ #'null is no longer in C, don't include its code in
+ byte-compile-checks-on-load.
+ * dumped-lisp.el:
+ * dumped-lisp.el (preloaded-file-list):
+ * loadup.el (gc-cons-threshold):
+ * loadup.el (really-early-error-handler):
+ * loadup.el (fboundp):
+ * make-docfile.el (done):
+ * make-docfile.el (process-args):
+ * make-docfile.el (preloaded-file-list):
+ * make-docfile.el (site-file-list):
+ * packages.el (packages-add-suffix):
+ * packages.el (packages-list-autoloads-path):
+ * update-elc.el:
+ * update-elc.el (preloaded-file-list):
+ * update-elc.el (or):
+ * update-elc.el (featurep):
+ * update-elc.el (do-autoload-commands):
+ Don't use those functions when running a bare-metal XEmacs binary.
+
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* make-docfile.el (docfile-out-of-date):
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/bytecomp.el
--- a/lisp/bytecomp.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/bytecomp.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -4645,7 +4645,7 ＠＠
block))))
(mapc 'byte-compile-form (cdr form)) ;; Push the arguments
(byte-compile-out (get (car form) 'byte-opcode) 0)
- (pushnew '(null (function-max-args 'throw)) byte-compile-checks-on-load
+ (pushnew '(eq (function-max-args 'throw) nil) byte-compile-checks-on-load
:test #'equal)))
;;; top-level forms elsewhere
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/dumped-lisp.el
--- a/lisp/dumped-lisp.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/dumped-lisp.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -318,4 +318,7 ＠＠
))
(setq preloaded-file-list
- (mapcan #'(lambda (x) (if (listp x) x (list x))) preloaded-file-list))
+ (mapcan #'(lambda (x) (if (or (consp x) (eq x nil)) x (list x)))
+ preloaded-file-list))
+
+;; dumped-lisp.el ends here
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/loadup.el
--- a/lisp/loadup.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/loadup.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -85,7 +85,7 ＠＠
;; setting it low makes loadup incredibly fucking slow.
;; no need to do it when not dumping.
(if (and purify-flag
- (not (memq 'quick-build internal-error-checking)))
+ (eq (memq 'quick-build internal-error-checking) nil))
30000 3000000)))
;; really-early-error-handler outputs a stack trace so let's not do it
＠＠ -156,7 +156,7 ＠＠
(external-debugging-output "Fatal error during load, aborting")
(kill-emacs 1))
(setq files (cdr files)))
- (when (not (featurep 'toolbar))
+ (unless (featurep 'toolbar)
;; else still define a few functions.
(defun toolbar-button-p (obj) "No toolbar support." nil)
(defun toolbar-specifier-p (obj) "No toolbar support." nil))
＠＠ -289,7 +289,7 ＠＠
;; this file must be loaded each time Emacs is run.
;; So run the startup code now.
-(when (not (fboundp 'dump-emacs))
+(unless (fboundp 'dump-emacs)
;; Avoid loading loadup.el a second time!
(setq command-line-args (cdr (cdr command-line-args)))
(eval top-level))
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/make-docfile.el
--- a/lisp/make-docfile.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/make-docfile.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -58,7 +58,7 ＠＠
;; First gather up the command line options.
(let (done)
- (while (and (null done) command-line-args)
+ (while (and (eq done nil) command-line-args)
(let ((arg (car command-line-args)))
(cond ((or (string-equal arg "-o") ; Specify DOC file name
(string-equal arg "-a") ; Append to DOC file
＠＠ -70,7 +70,7 ＠＠
((string-equal arg "-i") ; Set site files to scan
(setq site-file-list (car (cdr command-line-args))))
(t (setq done t)))
- (if (null done)
+ (if (eq done nil)
(setq command-line-args (cdr (cdr command-line-args)))))))
(setq options (nreverse options))
＠＠ -114,8 +114,8 ＠＠
(process-args (read buf)))
;; remove NEEDTODUMP and make-docfile.exe, convert .obj files into
;; .c files in the source directory.
- (when (and (not (string-match "\\(NEEDTODUMP\\|\\.exe$\\)" arg))
- (not (member arg processed)))
+ (when (and (eq (string-match "\\(NEEDTODUMP\\|\\.exe$\\)" arg) nil)
+ (eq (member arg processed) nil))
(when (string-match "\\(.*\\)\\.obj$" arg)
(setq arg (expand-file-name
(concatenate
＠＠ -125,7 +125,7 ＠＠
(subseq arg (match-beginning 1) (match-end 1)))
".c")
source-src)))
- (if (and (null docfile-out-of-date)
+ (if (and (eq docfile-out-of-date nil)
(file-newer-than-file-p arg docfile))
(setq docfile-out-of-date t))
(setq processed (cons arg processed))))
＠＠ -163,7 +163,7 ＠＠
(setq arg0 (packages-add-suffix (car preloaded-file-list))
arg (locate-library arg0)
absolute arg)
- (if (null arg)
+ (if (eq arg nil)
(progn
(message "Error: dumped file %s does not exist" arg0)
;; Uncomment in case of difficulties
＠＠ -182,9 +182,9 ＠＠
;; Use relative paths where possible, since this makes file lookup
;; in an installed XEmacs easier:
(setq arg arg0))
- (if (null (member arg processed))
+ (if (eq (member arg processed) nil)
(progn
- (if (and (null docfile-out-of-date)
+ (if (and (eq docfile-out-of-date nil)
;; We need to check the absolute path here:
(file-newer-than-file-p absolute docfile))
(setq docfile-out-of-date t))
＠＠ -197,9 +197,9 ＠＠
(load site-file-list t t)
(while site-load-packages
(let ((arg (car site-load-packages)))
- (if (null (member arg processed))
+ (if (eq (member arg processed) nil)
(progn
- (if (and (null docfile-out-of-date)
+ (if (and (eq docfile-out-of-date nil)
(file-newer-than-file-p arg docfile))
(setq docfile-out-of-date t))
(setq processed (cons arg processed)))))
＠＠ -254,7 +254,7 ＠＠
(write-sequence (buffer-substring nil nil standard-error)
'external-debugging-output)
(message "Spawning make-docfile ... %s"
- (if (zerop numeric-status) "done" status))
+ (if (equal 0 numeric-status) "done" status))
(kill-emacs numeric-status)))
(kill-emacs)
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/packages.el
--- a/lisp/packages.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/packages.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -178,10 +178,10 ＠＠
(message "No library %s in search path" library)))
result))
-(defun packages-add-suffix (str)
- (if (null (string-match "\\.el\\'" str))
- (concatenate 'string str ".elc")
- str))
+(defun packages-add-suffix (string)
+ (if (string-match-p "\\.el\\'" string)
+ string
+ (concatenate 'string string ".elc")))
(defun packages-list-autoloads-path ()
"List autoloads from precomputed load-path."
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/subr.el
--- a/lisp/subr.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/subr.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -230,6 +230,40 ＠＠
;; XEmacs; move these non-basic predicates that can be easily implemented in
;; Lisp from data.c.
+(defun null (object)
+ "Return t if OBJECT is nil."
+ (eq object nil))
+
+(defalias 'not #'null)
+
+(defun atom (object)
+ "Return t if OBJECT is not a cons cell. `nil' is not a cons cell.
+
+See the documentation for `cons' or the Lisp manual for more details on what
+a cons cell is."
+ (not (consp object)))
+
+(defun listp (object)
+ "Return t if OBJECT is a list. `nil' is a list.
+
+A list is either the Lisp object nil (a symbol), interpreted as the empty
+list in this context, or a cons cell whose CDR refers to either nil or a
+cons cell.
+
+A \"proper list\" contains no cycles. A \"true list\" is a proper list
+which has `nil' as the CDR of its last cons cell. See `true-list-p', an
+alternative, more expensive function, if these features are important for
+your use case."
+ (or (consp object) (eq object nil)))
+
+(defun nlistp (object)
+ "Return t if OBJECT is not a list. `nil' is a list."
+ (not (or (consp object) (eq object nil))))
+
+(defun bitp (object)
+ "Return t if OBJECT is a bit (0 or 1)."
+ (or (eql object 0) (eql object 1)))
+
(defun char-int-p (object)
"Return t if OBJECT is an integer that can be converted into a character.
See `char-int'."
＠＠ -268,7 +302,19 ＠＠
"Return t if OBJECT is a number, character or a marker."
(or (numberp object) (characterp object) (markerp object)))
-;; Also previously in data.c. Replaced in most uses by #'list-length.
+(defun zerop (number)
+ "Return t if NUMBER is zero."
+ (= number 0))
+
+(defun true-list-p (object)
+ "Return t if OBJECT is an acyclic, nil-terminated list."
+ (let ((hare object) (tortoise object) (length 0))
+ (while (and (consp hare) (or (not (eq hare tortoise)) (eql length 0)))
+ (if (eql (logand length 1) 1) (setq tortoise (cdr tortoise)))
+ (setq hare (cdr hare)
+ length (1+ length)))
+ (eq hare nil)))
+
(defun safe-length (list)
"Return the length of a list, but avoid error or infinite loop.
This function never gets an error. If LIST is not really a list,
diff -r 262dc5a418f5 -r 06e4b596dc40 lisp/update-elc.el
--- a/lisp/update-elc.el Wed Apr 25 08:14:02 2018 +0100
+++ b/lisp/update-elc.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -70,7 +70,7 ＠＠
; (if (file-newer-than-file-p src x)
; (progn
; (and (file-exists-p x)
-; (null (file-writable-p x))
+; (eq (file-writable-p x) nil)
; (set-file-modes x (logior (file-modes x) 128)))
; src))))))
; ;; -batch gets filtered out.
＠＠ -164,7 +164,7 ＠＠
(setq exe-target "src/temacs.exe"
dump-target "src/xemacs.exe"))
;; #### need better ways of getting config params
- ((not (memq 'pdump (emacs-run-status)))
+ ((eq (memq 'pdump (emacs-run-status)) nil)
(setq exe-target "src/temacs"
dump-target "src/xemacs"))
(t
＠＠ -176,9 +176,9 ＠＠
;; Not currently used.
; (setq dump-target-out-of-date-wrt-exe-target
-; (cond ((not dump-target) t)
+; (cond ((eq dump-target nil) t)
; (temacs-exe (file-newer-than-file-p temacs-exe dump-target))
-; ((not data-file) t)
+; ((eq data-file nil) t)
; (t (file-newer-than-file-p dump-target data-file))))
; (setq dump-target-exists (or (and temacs-exe dump-target)
; (and data-file dump-target))))
＠＠ -229,7 +229,7 ＠＠
(arg-sans-extension (update-elc-chop-extension arg))
(full-arg (locate-library arg-sans-extension))
(full-arg-sans-extension
- (if (null full-arg)
+ (if (eq full-arg nil)
(progn
(print (format "Error: Library file %s not found" arg))
(backtrace)
＠＠ -255,11 +255,11 ＠＠
(file-newer-than-file-p full-arg-elc dump-target)))
(setq dump-target-out-of-date-wrt-dump-files t))
- (if (and (not (member (file-name-nondirectory arg)
- unbytecompiled-lisp-files))
- (not (member (file-name-nondirectory arg)
- additional-dump-dependencies))
- (not (member full-arg-el processed))
+ (if (and (eq (member (file-name-nondirectory arg)
+ unbytecompiled-lisp-files) nil)
+ (eq (member (file-name-nondirectory arg)
+ additional-dump-dependencies) nil)
+ (eq (member full-arg-el processed) nil)
;; no need to check for existence of either of the files
;; because of the definition of file-newer-than-file-p.
(file-newer-than-file-p full-arg-el full-arg-elc))
＠＠ -281,11 +281,12 ＠＠
(let* ((full-arg (car all-files-in-dir)))
;; custom-load.el always gets regenerated so don't let that
;; trigger us.
- (when (and (not
+ (when (and (eq
(member
(file-name-nondirectory full-arg)
lisp-files-ignored-when-checking-for-autoload-updating
- ))
+ )
+ nil)
(file-newer-than-file-p full-arg autoload-file))
(if autoload-is-mule
(setq need-to-rebuild-mule-autoloads t)
＠＠ -306,7 +307,7 ＠＠
;; doesn't exist, need-to-rebuild-autoloads gets set above. but
;; it's only one call, so it won't slow things down much and it keeps
;; the logic cleaner.
- (not (file-exists-p aa-lisp))
+ (eq (file-exists-p aa-lisp) nil)
;; no need to check for file-exists of .elc due to definition
;; of file-newer-than-file-p
(file-newer-than-file-p aa-lisp aac-lisp))
＠＠ -314,13 +315,13 ＠＠
(when (or need-to-rebuild-mule-autoloads
;; not necessary but ... see comment above.
- (not (file-exists-p aa-lisp-mule))
+ (eq (file-exists-p aa-lisp-mule) nil)
;; no need to check for file-exists of .elc due to definition
;; of file-newer-than-file-p
(file-newer-than-file-p aa-lisp-mule aac-lisp-mule))
(setq need-to-recompile-mule-autoloads t))
-(when (not (featurep 'mule))
+(unless (featurep 'mule)
;; sorry charlie.
(setq need-to-rebuild-mule-autoloads nil
need-to-recompile-mule-autoloads nil))
＠＠ -350,14 +351,14 ＠＠
(condition-case nil
(delete-file (expand-file-name "src/REBUILD_AUTOLOADS" build-directory))
(file-error nil))
- (cond ((and (not update-elc-files-to-compile)
- (not need-to-rebuild-autoloads)
- (not need-to-rebuild-mule-autoloads)
- (not need-to-recompile-autoloads)
- (not need-to-recompile-mule-autoloads))
+ (cond ((and (eq update-elc-files-to-compile nil)
+ (eq need-to-rebuild-autoloads nil)
+ (eq need-to-rebuild-mule-autoloads nil)
+ (eq need-to-recompile-autoloads nil)
+ (eq need-to-recompile-mule-autoloads nil))
;; (1) Nothing to do at all.
)
- ((not update-elc-files-to-compile)
+ ((eq update-elc-files-to-compile nil)
;; (2) We have no files to byte-compile, but we do need to
;; regenerate and compile the auto-autoloads file, so signal
;; update-elc-2 to do it. This is much faster than loading
diff -r 262dc5a418f5 -r 06e4b596dc40 src/ChangeLog
--- a/src/ChangeLog Wed Apr 25 08:14:02 2018 +0100
+++ b/src/ChangeLog Wed Apr 25 21:49:16 2018 +0100
＠＠ -1,3 +1,25 ＠＠
+2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * data.c (Fatom, Flistp, Fnlistp, Fbitp, Fzerop, Ftrue_list_p):
+ Move all these functions to Lisp, since they are easily
+ implemented in Lisp, and having them in C necessitates extra space
+ in the dumped executable with NEWGC.
+ * data.c (Flistp):
+ * data.c (syms_of_data):
+ Remove various DEFSUBRs from here.
+
+ * data.c (Fnonnegativep):
+ Document that this returns t if OBJECT is a nonnegative rational,
+ rather than a number in general.
+ * data.c (Fnumberp):
+ Document that this returns t if OBJECT is a floating point or a
+ rational, rather than just an integer.
+ * data.c:
+
+ * lisp.h:
+ * tooltalk.c (tooltalk_message_callback):
+ Use Ffunctionp() here rather than re-implementing it.
+
2018-04-23 Aidan Kehoe <kehoea(a)parhasard.net>
* abbrev.c (Fexpand_abbrev):
diff -r 262dc5a418f5 -r 06e4b596dc40 src/data.c
--- a/src/data.c Wed Apr 25 08:14:02 2018 +0100
+++ b/src/data.c Wed Apr 25 21:49:16 2018 +0100
＠＠ -57,7 +57,7 ＠＠
Lisp_Object Qarith_error, Qrange_error, Qdomain_error;
Lisp_Object Qsingularity_error, Qoverflow_error, Qunderflow_error;
Lisp_Object Qintegerp, Qnatnump, Qnonnegativep, Qsymbolp;
-Lisp_Object Qlistp, Qtrue_list_p, Qweak_listp;
+Lisp_Object Qlistp, Qweak_listp;
Lisp_Object Qconsp, Qsubrp;
Lisp_Object Qcharacterp, Qstringp, Qarrayp, Qsequencep, Qvectorp;
Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qbufferp;
＠＠ -188,15 +188,7 ＠＠
{
return EQ_WITH_EBOLA_NOTICE (object1, object2) ? Qt : Qnil;
}
-
-DEFUN ("null", Fnull, 1, 1, 0, /*
-Return t if OBJECT is nil.
-*/
- (object))
-{
- return NILP (object) ? Qt : Qnil;
-}
-
+
DEFUN ("consp", Fconsp, 1, 1, 0, /*
Return t if OBJECT is a cons cell. `nil' is not a cons cell.
＠＠ -208,45 +200,6 ＠＠
return CONSP (object) ? Qt : Qnil;
}
-DEFUN ("atom", Fatom, 1, 1, 0, /*
-Return t if OBJECT is not a cons cell. `nil' is not a cons cell.
-
-See the documentation for `cons' or the Lisp manual for more details on what
-a cons cell is.
-*/
- (object))
-{
- return CONSP (object) ? Qnil : Qt;
-}
-
-DEFUN ("listp", Flistp, 1, 1, 0, /*
-Return t if OBJECT is a list. `nil' is a list.
-
-A list is either the Lisp object nil (a symbol), interpreted as the empty
-list in this context, or a cons cell whose CDR refers to either nil or a
-cons cell. A "proper list" contains no cycles.
-*/
- (object))
-{
- return LISTP (object) ? Qt : Qnil;
-}
-
-DEFUN ("nlistp", Fnlistp, 1, 1, 0, /*
-Return t if OBJECT is not a list. `nil' is a list.
-*/
- (object))
-{
- return LISTP (object) ? Qnil : Qt;
-}
-
-DEFUN ("true-list-p", Ftrue_list_p, 1, 1, 0, /*
-Return t if OBJECT is an acyclic, nil-terminated (ie, not dotted), list.
-*/
- (object))
-{
- return TRUE_LIST_P (object) ? Qt : Qnil;
-}
-
DEFUN ("symbolp", Fsymbolp, 1, 1, 0, /*
Return t if OBJECT is a symbol.
＠＠ -456,7 +409,7 ＠＠
}
DEFUN ("nonnegativep", Fnonnegativep, 1, 1, 0, /*
-Return t if OBJECT is a nonnegative number.
+Return t if OBJECT is a nonnegative rational.
*/
(object))
{
＠＠ -470,16 +423,8 ＠＠
? Qt : Qnil;
}
-DEFUN ("bitp", Fbitp, 1, 1, 0, /*
-Return t if OBJECT is a bit (0 or 1).
-*/
- (object))
-{
- return BITP (object) ? Qt : Qnil;
-}
-
DEFUN ("numberp", Fnumberp, 1, 1, 0, /*
-Return t if OBJECT is a number (floating point or integer).
+Return t if OBJECT is a number (floating point or rational).
*/
(object))
{
＠＠ -1109,34 +1054,6 ＠＠
#endif /* WITH_NUMBER_TYPES */
}
-DEFUN ("zerop", Fzerop, 1, 1, 0, /*
-Return t if NUMBER is zero.
-*/
- (number))
-{
- retry:
- if (FIXNUMP (number))
- return EQ (number, Qzero) ? Qt : Qnil;
-#ifdef HAVE_BIGNUM
- else if (BIGNUMP (number))
- return bignum_sign (XBIGNUM_DATA (number)) == 0 ? Qt : Qnil;
-#endif
-#ifdef HAVE_RATIO
- else if (RATIOP (number))
- return ratio_sign (XRATIO_DATA (number)) == 0 ? Qt : Qnil;
-#endif
- else if (FLOATP (number))
- return XFLOAT_DATA (number) == 0.0 ? Qt : Qnil;
-#ifdef HAVE_BIGFLOAT
- else if (BIGFLOATP (number))
- return bigfloat_sign (XBIGFLOAT_DATA (number)) == 0 ? Qt : Qnil;
-#endif
- else
- {
- number = wrong_type_argument (Qnumberp, number);
- goto retry;
- }
-}
/* Convert between an unsigned 32-bit value and some Lisp value that preserves
all its bits. Use an integer if the value will fit (that is, if the value
＠＠ -4429,7 +4346,6 ＠＠
DEFSYMBOL (Qlambda);
DEFSYMBOL (Qlistp);
- DEFSYMBOL (Qtrue_list_p);
DEFSYMBOL (Qconsp);
DEFSYMBOL (Qsubrp);
DEFSYMBOL (Qsymbolp);
＠＠ -4466,13 +4382,7 ＠＠
DEFSUBR (Fdiv);
#endif
DEFSUBR (Feq);
- DEFSUBR (Fnull);
- Ffset (intern ("not"), intern ("null"));
- DEFSUBR (Flistp);
- DEFSUBR (Fnlistp);
- DEFSUBR (Ftrue_list_p);
DEFSUBR (Fconsp);
- DEFSUBR (Fatom);
DEFSUBR (Fcharacterp);
DEFSUBR (Fchar_to_int);
DEFSUBR (Fint_to_char);
＠＠ -4486,7 +4396,6 ＠＠
DEFSUBR (Fkeywordp);
DEFSUBR (Fstringp);
DEFSUBR (Fvectorp);
- DEFSUBR (Fbitp);
DEFSUBR (Fbit_vector_p);
DEFSUBR (Farrayp);
DEFSUBR (Fsequencep);
＠＠ -4517,7 +4426,6 ＠＠
DEFSUBR (Fleq);
DEFSUBR (Fgeq);
DEFSUBR (Fneq);
- DEFSUBR (Fzerop);
DEFSUBR (Fplus);
DEFSUBR (Fminus);
DEFSUBR (Ftimes);
diff -r 262dc5a418f5 -r 06e4b596dc40 src/lisp.h
--- a/src/lisp.h Wed Apr 25 08:14:02 2018 +0100
+++ b/src/lisp.h Wed Apr 25 21:49:16 2018 +0100
＠＠ -2646,31 +2646,6 ＠＠
} \
while (0)
-/* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */
-DECLARE_INLINE_HEADER (
-int
-TRUE_LIST_P (Lisp_Object object)
-)
-{
- Lisp_Object hare, tortoise;
- EMACS_INT len;
-
- for (hare = tortoise = object, len = 0;
- CONSP (hare);
- hare = XCDR (hare), len++)
- {
- if (len < CIRCULAR_LIST_SUSPICION_LENGTH)
- continue;
-
- if (len & 1)
- tortoise = XCDR (tortoise);
- else if (EQ (hare, tortoise))
- return 0;
- }
-
- return NILP (hare);
-}
-
/* Signal an error if LIST is not properly acyclic and nil-terminated. */
#define CHECK_TRUE_LIST(list) do { \
Lisp_Object CTL_list = (list); \
＠＠ -4661,7 +4636,6 ＠＠
EXFUN (Fgtr, MANY);
EXFUN (Findirect_function, 1);
EXFUN (Fleq, MANY);
-EXFUN (Flistp, 1);
EXFUN (Flss, MANY);
EXFUN (Fmax, MANY);
EXFUN (Fmin, MANY);
＠＠ -4727,7 +4701,7 ＠＠
extern Lisp_Object Qarrayp, Qbitp, Qchar_or_string_p, Qcharacterp,
Qerror_conditions, Qerror_message, Qinteger_char_or_marker_p,
Qinteger_or_char_p, Qinteger_or_marker_p, Qlambda, Qlistp, Qnatnump,
- Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote, Qtrue_list_p;
+ Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote;
extern MODULE_API Lisp_Object Qintegerp;
extern Lisp_Object Qargs_out_of_range, Qarith_error, Qbeginning_of_buffer,
diff -r 262dc5a418f5 -r 06e4b596dc40 src/tooltalk.c
--- a/src/tooltalk.c Wed Apr 25 08:14:02 2018 +0100
+++ b/src/tooltalk.c Wed Apr 25 21:49:16 2018 +0100
＠＠ -362,9 +362,7 ＠＠
va_run_hook_with_args (Qtooltalk_message_handler_hook, 2,
message_, pattern);
- if ((SYMBOLP (cb) && EQ (Qt, Ffboundp (cb))) ||
- (CONSP (cb) && EQ (Qlambda, Fcar (cb)) &&
- !NILP (Flistp (Fcar (Fcdr (cb))))))
+ if (!NILP (Ffunctionp (cb)))
call2 (cb, message_, pattern);
UNGCPRO;
diff -r 262dc5a418f5 -r 06e4b596dc40 tests/ChangeLog
--- a/tests/ChangeLog Wed Apr 25 08:14:02 2018 +0100
+++ b/tests/ChangeLog Wed Apr 25 21:49:16 2018 +0100
＠＠ -1,3 +1,9 ＠＠
+2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * automated/lisp-tests.el:
+ Test various of the simple predicates just moved to subr.el from
+ data.c.
+
2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
* automated/os-tests.el (two-to-the-thirty-second):
diff -r 262dc5a418f5 -r 06e4b596dc40 tests/automated/lisp-tests.el
--- a/tests/automated/lisp-tests.el Wed Apr 25 08:14:02 2018 +0100
+++ b/tests/automated/lisp-tests.el Wed Apr 25 21:49:16 2018 +0100
＠＠ -4330,4 +4330,59 ＠＠
'file-name t)))))
(define-coding-system-alias 'file-name file-name-alias))))
+;;-----------------------------------------------------
+;; Testing some used-to-be-primitives, now in subr.el
+;;-----------------------------------------------------
+
+(Assert (eq (atom nil) t))
+(Assert (eq (atom 0) t))
+(Assert (not (atom '(1 . 0))))
+(Assert (not (atom (make-circular-list 28 'a))))
+
+(Assert (eq (listp '(1 . 0)) t))
+(Assert (eq (listp nil) t))
+(Assert (not (listp '#:nil)))
+(Assert (not (listp [nil])))
+(Assert (eq (listp (make-circular-list 14 'b)) t))
+
+(Assert (bitp 1))
+(Assert (bitp 0))
+(Assert (not (bitp 2)))
+(Assert (not (bitp 0.0)))
+(Assert (not (bitp 1.0)))
+
+(Assert (zerop 0))
+(Assert (zerop 0.0))
+(Assert (not (zerop 1)))
+(Assert (not (zerop 1.0)))
+(Check-Error 'wrong-type-argument (zerop '#:0))
+(Check-Error 'wrong-type-argument (zerop '\0))
+(Check-Error 'wrong-type-argument (zerop [hello]))
+
+(Assert (char-int-p #x61))
+(Assert (char-int-p #x41))
+(Assert (char-int-p #xff))
+(Assert (not (char-int-p -1)))
+(Assert (not (char-int-p (1+ 1073741823))))
+(Assert (not (char-int-p (+ #x61 0.0))))
+(Assert (not (char-int-p "a")))
+
+(Assert (char-or-string-p ?A))
+(Assert (char-or-string-p "A"))
+(Assert (char-or-string-p "\x00"))
+(Assert (char-or-string-p ?\x00))
+(Assert (char-or-string-p #x00))
+(Assert (char-or-string-p (make-string 1024 ?z)))
+(Assert (char-or-string-p #x00))
+(Assert (not (char-or-string-p [?a])))
+(Assert (not (char-or-string-p -1)))
+(Assert (not (char-or-string-p (1+ 1073741823))))
+(Assert (not (char-or-string-p (+ ?A 0.0))))
+
+(Assert (true-list-p nil))
+(Assert (true-list-p '(a b c d)))
+(Assert (true-list-p (cons 'a nil)))
+(Assert (not (true-list-p [])))
+(Assert (not (true-list-p -1)))
+
;;; end of lisp-tests.el
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 3 participants
- 3 comments
[COMMIT] Handle non-numeric STATUS more gracefully, make-docfile.el
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524640442 -3600
# Wed Apr 25 08:14:02 2018 +0100
# Node ID 262dc5a418f5aed7f0284e8d63e39ba6a529166c
# Parent c5889f9bb7f42149ee575ea6553eebe24a2652b8
Handle non-numeric STATUS more gracefully, make-docfile.el
lisp/ChangeLog addition:
2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
* make-docfile.el (docfile-out-of-date):
#'call-process can return a non-integer if the underlying process
signaled, and exited for that reason. Handle this more gracefully.
diff -r c5889f9bb7f4 -r 262dc5a418f5 lisp/ChangeLog
--- a/lisp/ChangeLog Mon Apr 23 13:43:40 2018 +0100
+++ b/lisp/ChangeLog Wed Apr 25 08:14:02 2018 +0100
＠＠ -1,3 +1,9 ＠＠
+2018-04-25 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * make-docfile.el (docfile-out-of-date):
+ #'call-process can return a non-integer if the underlying process
+ signaled, and exited for that reason. Handle this more gracefully.
+
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* code-files.el (write-region):
diff -r c5889f9bb7f4 -r 262dc5a418f5 lisp/make-docfile.el
--- a/lisp/make-docfile.el Mon Apr 23 13:43:40 2018 +0100
+++ b/lisp/make-docfile.el Wed Apr 25 08:14:02 2018 +0100
＠＠ -245,16 +245,17 ＠＠
;; (expand-file-name "make-docfile" build-lib-src)
"make-docfile"
nil
+ ;; Wouldn't it be nice to have streams as process input and
+ ;; output.
(list t standard-error)
nil
- (append options processed))))
- (if (equal status 0)
- (message "%sSpawning make-docfile ...done"
- (buffer-substring nil nil standard-error))
- (message "%sSpawning make-docfile ... error, failed with status %d."
- (buffer-substring nil nil standard-error)
- status))
- (kill-emacs status)))
+ (append options processed)))
+ (numeric-status (if (integerp status) status 1)))
+ (write-sequence (buffer-substring nil nil standard-error)
+ 'external-debugging-output)
+ (message "Spawning make-docfile ... %s"
+ (if (zerop numeric-status) "done" status))
+ (kill-emacs numeric-status)))
(kill-emacs)
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Quiet warnings with -Wnarrowing, GCC, improving quality on 64 bit builds
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524487420 -3600
# Mon Apr 23 13:43:40 2018 +0100
# Node ID c5889f9bb7f42149ee575ea6553eebe24a2652b8
# Parent 046a3f85a39d07ff8186173630a42b06eb1ec1f5
Quiet warnings with -Wnarrowing, GCC, improving quality on 64 bit builds
src/ChangeLog addition:
2018-04-23 Aidan Kehoe <kehoea(a)parhasard.net>
* abbrev.c (Fexpand_abbrev):
* alloc.c (struct):
* alloc.c (malloc_after):
* alloc.c (xmalloc):
* alloc.c (xcalloc):
* alloc.c (xrealloc):
* alloc.c (xstrdup):
* alloc.c (alloc_sized_lrecord_1):
* alloc.c (alloc_sized_lrecord_array):
* alloc.c (alloc_lrecord_array):
* alloc.c (copy_lisp_object):
* alloc.c (dbg_inhibit_dbg_symbol_deletion):
* alloc.c (make_uninit_vector):
* alloc.c (Fvector):
* alloc.c (bit_vector_equal):
* alloc.c (make_bit_vector):
* alloc.c (string_equal):
* alloc.c (resize_string):
* alloc.c (set_string_char):
* alloc.c (Fmake_string):
* alloc.c (Fstring):
* alloc.c (init_string_ascii_begin):
* alloc.c (make_string):
* alloc.c (dec_lrecord_stats):
* alloc.c (lrecord_stats_heap_size):
* alloc.c (pluralize_word):
* array.c (Dynarr_realloc):
* array.c (Dynarr_insert_many):
* array.c (Dynarr_delete_many):
* array.c (gap_array_move_gap):
* array.h:
* array.h (Dynarr_declare):
* array.h (Dynarr_delete_object):
* array.h (gap_array_marker):
* buffer.c (MARKED_SLOT):
* buffer.c (Fgenerate_new_buffer_name):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.h (struct buffer):
* bytecode.c (make_compiled_function_args):
* bytecode.c (UNUSED):
* callint.c (Fcall_interactively):
* casefiddle.c (casify_object):
* casefiddle.c (casify_region_internal):
* charset.h:
* chartab.c (clone_chartab_table):
* chartab.c (put_char_table):
* chartab.c (decode_char_table_range):
* cmds.c (Fpoint_at_bol):
* cmds.c (Fpoint_at_eol):
* cmds.c (internal_self_insert):
* console.c (delete_console_internal):
* console.c (Fset_input_mode):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.h:
* data.c (lisp_to_uint32_t):
* data.c (lisp_to_int32_t):
* data.c (rem_two_fixnum):
* data.c (Flsh):
* debug.c (FROB):
* device.c (Fmake_device):
* device.c (delete_device_internal):
* device.c (Fset_device_baud_rate):
* device.h:
* doc.c (extract_object_file_name):
* doc.c (Fsnarf_documentation):
* doc.c (verify_doc_mapper):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (Fnumber_to_string):
* doprnt.c (emacs_doprnt):
* editfns.c (Finsert_char):
* editfns.c (save_restriction_restore):
* elhash.c (internal_array_hash):
* filelock.c (LOCK_PID_MAX):
* filelock.c (fill_in_lock_file_name):
* filelock.c (current_lock_owner):
* indent.c:
* indent.c (column_at_point):
* indent.c (string_column_at_point):
* indent.c (current_column):
* indent.c (Findent_to):
* indent.c (byte_spaces_at_point):
* indent.c (Fmove_to_column):
* indent.c (Fcompute_motion):
* indent.c (vertical_motion_1):
* indent.c (Fvertical_motion_pixels):
* lisp-disunion.h (XCHARVAL):
* lisp-disunion.h (wrap_pointer_1):
* lisp.h:
* lisp.h (ALLOCA):
* lisp.h (XSET_STRING_ASCII_BEGIN):
* lisp.h (CHECK_CHAR_COERCE_INT):
* lisp.h (LISP_HASH):
* lisp.h (struct gcpro):
* lisp.h (DECLARE_INLINE_HEADER):
* lrecord.h:
* lrecord.h (set_lheader_implementation):
* number.h:
* number.h (integer_signum):
* number.h (NATNUMP):
* print.c (debug_short_backtrace):
* search.c (find_before_next_newline):
* syntax.c (scan_words):
* syntax.h:
* sysdep.c:
* sysdep.c (wait_for_termination):
* sysdep.c (sys_subshell):
* sysdep.c (sys_suspend):
* sysdep.c (init_sigio_on_device):
* sysdep.c (qxe_readlink):
* sysfile.h:
* text.c (eifind_large_enough_buffer):
* text.h:
* text.h (ASSERT_ASCTEXT_ASCII_LEN):
* text.h (struct):
* text.h (EI_ALLOC):
* text.h (eicpy_lstr_off):
* text.h (eicpy_raw_fmt):
* text.h (eicpy_ascii_len):
* text.h (eicpy_ext_len):
* text.h (eimake_string_off):
* text.h (DECLARE_INLINE_HEADER):
* text.h (eicat_1):
* text.h (eicat_ascii):
* text.h (eicat_raw):
* text.h (eisub_1):
* text.h (eisub_ascii):
* text.h (EI_CASECHANGE):
* undo.c (truncate_undo_list):
* unicode.c (print_precedence_array):
Be more careful about integer types within the C code, e.g. not
using an int where a value represents a (possibly large) number of
bytes, or characters, especially relevant for values like fill
columns, which can usefully be set to most-positive-fixnum,
something the code up to now dealt with badly on a 64-bit build.
Issues flushed out using the -Wnarrowing GCC option.
* lisp.h (XCHAR_OR_CHAR_INT):
Provide an error-checking version of this to check uses with
fixnums where valid_ichar_p() is not true.
* lisp.h (GOOD_HASH):
Set this to a prime number just over 2^32 on sixty-four bit
architectures, of type Hashcode, an unsigned type, so modular
arithmetic is defined.
diff -r 046a3f85a39d -r c5889f9bb7f4 src/ChangeLog
--- a/src/ChangeLog Sat Apr 21 16:49:20 2018 +0100
+++ b/src/ChangeLog Mon Apr 23 13:43:40 2018 +0100
＠＠ -1,3 +1,150 ＠＠
+2018-04-23 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * abbrev.c (Fexpand_abbrev):
+ * alloc.c (struct):
+ * alloc.c (malloc_after):
+ * alloc.c (xmalloc):
+ * alloc.c (xcalloc):
+ * alloc.c (xrealloc):
+ * alloc.c (xstrdup):
+ * alloc.c (alloc_sized_lrecord_1):
+ * alloc.c (alloc_sized_lrecord_array):
+ * alloc.c (alloc_lrecord_array):
+ * alloc.c (copy_lisp_object):
+ * alloc.c (dbg_inhibit_dbg_symbol_deletion):
+ * alloc.c (make_uninit_vector):
+ * alloc.c (Fvector):
+ * alloc.c (bit_vector_equal):
+ * alloc.c (make_bit_vector):
+ * alloc.c (string_equal):
+ * alloc.c (resize_string):
+ * alloc.c (set_string_char):
+ * alloc.c (Fmake_string):
+ * alloc.c (Fstring):
+ * alloc.c (init_string_ascii_begin):
+ * alloc.c (make_string):
+ * alloc.c (dec_lrecord_stats):
+ * alloc.c (lrecord_stats_heap_size):
+ * alloc.c (pluralize_word):
+ * array.c (Dynarr_realloc):
+ * array.c (Dynarr_insert_many):
+ * array.c (Dynarr_delete_many):
+ * array.c (gap_array_move_gap):
+ * array.h:
+ * array.h (Dynarr_declare):
+ * array.h (Dynarr_delete_object):
+ * array.h (gap_array_marker):
+ * buffer.c (MARKED_SLOT):
+ * buffer.c (Fgenerate_new_buffer_name):
+ * buffer.c (DEFVAR_BUFFER_LOCAL_1):
+ * buffer.h (struct buffer):
+ * bytecode.c (make_compiled_function_args):
+ * bytecode.c (UNUSED):
+ * callint.c (Fcall_interactively):
+ * casefiddle.c (casify_object):
+ * casefiddle.c (casify_region_internal):
+ * charset.h:
+ * chartab.c (clone_chartab_table):
+ * chartab.c (put_char_table):
+ * chartab.c (decode_char_table_range):
+ * cmds.c (Fpoint_at_bol):
+ * cmds.c (Fpoint_at_eol):
+ * cmds.c (internal_self_insert):
+ * console.c (delete_console_internal):
+ * console.c (Fset_input_mode):
+ * console.c (DEFVAR_CONSOLE_LOCAL_1):
+ * console.h:
+ * data.c (lisp_to_uint32_t):
+ * data.c (lisp_to_int32_t):
+ * data.c (rem_two_fixnum):
+ * data.c (Flsh):
+ * debug.c (FROB):
+ * device.c (Fmake_device):
+ * device.c (delete_device_internal):
+ * device.c (Fset_device_baud_rate):
+ * device.h:
+ * doc.c (extract_object_file_name):
+ * doc.c (Fsnarf_documentation):
+ * doc.c (verify_doc_mapper):
+ * doc.c (Fsubstitute_command_keys):
+ * doprnt.c (Fnumber_to_string):
+ * doprnt.c (emacs_doprnt):
+ * editfns.c (Finsert_char):
+ * editfns.c (save_restriction_restore):
+ * elhash.c (internal_array_hash):
+ * filelock.c (LOCK_PID_MAX):
+ * filelock.c (fill_in_lock_file_name):
+ * filelock.c (current_lock_owner):
+ * indent.c:
+ * indent.c (column_at_point):
+ * indent.c (string_column_at_point):
+ * indent.c (current_column):
+ * indent.c (Findent_to):
+ * indent.c (byte_spaces_at_point):
+ * indent.c (Fmove_to_column):
+ * indent.c (Fcompute_motion):
+ * indent.c (vertical_motion_1):
+ * indent.c (Fvertical_motion_pixels):
+ * lisp-disunion.h (XCHARVAL):
+ * lisp-disunion.h (wrap_pointer_1):
+ * lisp.h:
+ * lisp.h (ALLOCA):
+ * lisp.h (XSET_STRING_ASCII_BEGIN):
+ * lisp.h (CHECK_CHAR_COERCE_INT):
+ * lisp.h (LISP_HASH):
+ * lisp.h (struct gcpro):
+ * lisp.h (DECLARE_INLINE_HEADER):
+ * lrecord.h:
+ * lrecord.h (set_lheader_implementation):
+ * number.h:
+ * number.h (integer_signum):
+ * number.h (NATNUMP):
+ * print.c (debug_short_backtrace):
+ * search.c (find_before_next_newline):
+ * syntax.c (scan_words):
+ * syntax.h:
+ * sysdep.c:
+ * sysdep.c (wait_for_termination):
+ * sysdep.c (sys_subshell):
+ * sysdep.c (sys_suspend):
+ * sysdep.c (init_sigio_on_device):
+ * sysdep.c (qxe_readlink):
+ * sysfile.h:
+ * text.c (eifind_large_enough_buffer):
+ * text.h:
+ * text.h (ASSERT_ASCTEXT_ASCII_LEN):
+ * text.h (struct):
+ * text.h (EI_ALLOC):
+ * text.h (eicpy_lstr_off):
+ * text.h (eicpy_raw_fmt):
+ * text.h (eicpy_ascii_len):
+ * text.h (eicpy_ext_len):
+ * text.h (eimake_string_off):
+ * text.h (DECLARE_INLINE_HEADER):
+ * text.h (eicat_1):
+ * text.h (eicat_ascii):
+ * text.h (eicat_raw):
+ * text.h (eisub_1):
+ * text.h (eisub_ascii):
+ * text.h (EI_CASECHANGE):
+ * undo.c (truncate_undo_list):
+ * unicode.c (print_precedence_array):
+ Be more careful about integer types within the C code, e.g. not
+ using an int where a value represents a (possibly large) number of
+ bytes, or characters, especially relevant for values like fill
+ columns, which can usefully be set to most-positive-fixnum,
+ something the code up to now dealt with badly on a 64-bit build.
+ Issues flushed out using the -Wnarrowing GCC option.
+
+ * lisp.h (XCHAR_OR_CHAR_INT):
+ Provide an error-checking version of this to check uses with
+ fixnums where valid_ichar_p() is not true.
+
+ * lisp.h (GOOD_HASH):
+ Set this to a prime number just over 2^32 on sixty-four bit
+ architectures, of type Hashcode, an unsigned type, so modular
+ arithmetic is defined.
+
2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
* data.c:
diff -r 046a3f85a39d -r c5889f9bb7f4 src/abbrev.c
--- a/src/abbrev.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/abbrev.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -284,7 +284,7 ＠＠
{
/* This function can GC */
struct buffer *buf = current_buffer;
- int oldmodiff = BUF_MODIFF (buf);
+ EMACS_INT oldmodiff = BUF_MODIFF (buf);
Lisp_Object pre_modiff_p;
Charbpos point; /* position of point */
Charbpos abbrev_start; /* position of abbreviation beginning */
diff -r 046a3f85a39d -r c5889f9bb7f4 src/alloc.c
--- a/src/alloc.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/alloc.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -150,9 +150,9 ＠＠
static struct
{
- int instances_in_use;
- int bytes_in_use;
- int bytes_in_use_including_overhead;
+ Elemcount instances_in_use;
+ Bytecount bytes_in_use;
+ Bytecount bytes_in_use_including_overhead;
} lrecord_stats [countof (lrecord_implementations_table)];
#else /* not NEW_GC */
＠＠ -315,7 +315,7 ＠＠
static void
malloc_after (void *val, Bytecount size)
{
- if (!val && size != 0)
+ if (size < 0 || (!val && size != 0))
memory_full ();
set_alloc_mins_and_maxes (val, size);
}
＠＠ -393,7 +393,7 ＠＠
{
void *val;
MALLOC_BEGIN ();
- val = malloc (size);
+ val = malloc ((size_t) size);
MALLOC_END ();
malloc_after (val, size);
return val;
＠＠ -405,7 +405,7 ＠＠
{
void *val;
MALLOC_BEGIN ();
- val= calloc (nelem, elsize);
+ val= calloc ((size_t) nelem, (size_t) elsize);
MALLOC_END ();
malloc_after (val, nelem * elsize);
return val;
＠＠ -422,7 +422,7 ＠＠
xrealloc (void *block, Bytecount size)
{
FREE_OR_REALLOC_BEGIN (block);
- block = realloc (block, size);
+ block = realloc (block, (size_t) size);
MALLOC_END ();
malloc_after (block, size);
return block;
＠＠ -454,8 +454,10 ＠＠
char *
xstrdup (const char *str)
{
- int len = strlen (str) + 1; /* for stupid terminating 0 */
- void *val = xmalloc (len);
+ size_t len = strlen (str) + 1; /* for stupid terminating 0 */
+ void *val;
+
+ val = xmalloc ((Bytecount) len);
if (val == 0) return 0;
return (char *) memcpy (val, str, len);
＠＠ -596,7 +598,7 ＠＠
assert_proper_sizing (size);
- lheader = (struct lrecord_header *) mc_alloc (size);
+ lheader = (struct lrecord_header *) mc_alloc ((size_t) size);
gc_checking_assert (LRECORD_FREE_P (lheader));
set_lheader_implementation (lheader, implementation);
#ifdef ALLOC_TYPE_STATS
＠＠ -641,7 +643,7 ＠＠
}
Lisp_Object
-alloc_sized_lrecord_array (Bytecount size, int elemcount,
+alloc_sized_lrecord_array (Bytecount size, Elemcount elemcount,
const struct lrecord_implementation *implementation)
{
struct lrecord_header *lheader;
＠＠ -671,7 +673,7 ＠＠
}
Lisp_Object
-alloc_lrecord_array (int elemcount,
+alloc_lrecord_array (Elemcount elemcount,
const struct lrecord_implementation *implementation)
{
type_checking_assert (implementation->static_size > 0);
＠＠ -767,7 +769,7 ＠＠
#ifdef NEW_GC
memcpy ((char *) XRECORD_LHEADER (dst) + sizeof (struct lrecord_header),
(char *) XRECORD_LHEADER (src) + sizeof (struct lrecord_header),
- size - sizeof (struct lrecord_header));
+ size - (Bytecount) sizeof (struct lrecord_header));
#else /* not NEW_GC */
if (imp->frob_block_p)
memcpy ((char *) XRECORD_LHEADER (dst) + sizeof (struct lrecord_header),
＠＠ -896,8 +898,8 ＠＠
/* On some systems, the above definitions will be optimized away by
the compiler or linker unless they are referenced in some function. */
-long dbg_inhibit_dbg_symbol_deletion (void);
-long
+EMACS_UINT dbg_inhibit_dbg_symbol_deletion (void);
+EMACS_UINT
dbg_inhibit_dbg_symbol_deletion (void)
{
return
＠＠ -1857,7 +1859,7 ＠＠
make_uninit_vector (Elemcount sizei)
{
/* no `next' field; we use lcrecords */
- EMACS_UINT sizeui = sizei;
+ EMACS_UINT sizeui = (EMACS_UINT) sizei;
EMACS_UINT sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object,
contents, sizeui);
Lisp_Object obj;
＠＠ -1910,7 +1912,7 ＠＠
check_integer_range() does <=, adjust for this. */
make_fixnum (ARRAY_DIMENSION_LIMIT - 1));
result = make_uninit_vector (nargs);
- memcpy (XVECTOR_DATA (result), args, sizeof (Lisp_Object) * nargs);
+ memcpy (XVECTOR_DATA (result), args, sizeof (Lisp_Object) * (size_t) nargs);
return result;
}
＠＠ -2057,8 +2059,8 ＠＠
return ((bit_vector_length (v1) == bit_vector_length (v2)) &&
!memcmp (v1->bits, v2->bits,
- BIT_VECTOR_LONG_STORAGE (bit_vector_length (v1)) *
- sizeof (long)));
+ (size_t) BIT_VECTOR_LONG_STORAGE (bit_vector_length (v1))
+ * sizeof (long)));
}
/* This needs to be algorithmically identical to internal_array_hash in
＠＠ -2156,15 +2158,18 ＠＠
{
Lisp_Bit_Vector *p = make_bit_vector_internal (length);
Elemcount num_longs = BIT_VECTOR_LONG_STORAGE (length);
+ size_t bcount = (size_t) num_longs * sizeof (long);
CHECK_BIT (bit);
+ structure_checking_assert ((bcount / (size_t) num_longs) == sizeof (long));
+
if (ZEROP (bit))
- memset (p->bits, 0, num_longs * sizeof (long));
+ memset (p->bits, 0, bcount);
else
{
Elemcount bits_in_last = length & (LONGBITS_POWER_OF_2 - 1);
- memset (p->bits, ~0, num_longs * sizeof (long));
+ memset (p->bits, ~0, bcount);
/* But we have to make sure that the unused bits in the
last long are 0, so that equal/hash is easy. */
if (bits_in_last)
＠＠ -2672,7 +2677,8 ＠＠
return !lisp_strcasecmp_i18n (obj1, obj2);
else
return (((len = XSTRING_LENGTH (obj1)) == XSTRING_LENGTH (obj2)) &&
- !memcmp (XSTRING_DATA (obj1), XSTRING_DATA (obj2), len));
+ !memcmp (XSTRING_DATA (obj1), XSTRING_DATA (obj2),
+ (size_t) len));
}
static const struct memory_description string_description[] = {
＠＠ -3056,14 +3062,16 ＠＠
if (delta < 0 && pos >= 0)
memmove (XSTRING_DATA (s) + pos + delta,
- XSTRING_DATA (s) + pos, len);
+ /* LEN is guaranteed greater than zero. */
+ XSTRING_DATA (s) + pos, (size_t) len);
XSTRING_DATA_OBJECT (s) =
wrap_string_direct_data (mc_realloc (XPNTR (XSTRING_DATA_OBJECT (s)),
newfullsize));
if (delta > 0 && pos >= 0)
memmove (XSTRING_DATA (s) + pos + delta, XSTRING_DATA (s) + pos,
- len);
+ /* LEN is guaranteed greater than zero. */
+ (size_t) len);
#else /* not NEW_GC */
oldfullsize = STRING_FULLSIZE (XSTRING_LENGTH (s));
＠＠ -3222,10 +3230,10 ＠＠
/* XSTRING_DATA (ss) might have changed, reload it. */
data = XSTRING_DATA (ss) + bytoff;
- memcpy (data, newstr, newlen);
+ memcpy (data, newstr, (size_t) newlen);
if (oldlen != newlen)
{
- if (newlen > 1 && idx <= (Charcount) XSTRING_ASCII_BEGIN (ss))
+ if (newlen > 1 && idx < (Charcount) XSTRING_ASCII_BEGIN (ss))
/* Everything starting with the new char is no longer part of
ascii_begin */
XSET_STRING_ASCII_BEGIN (ss, idx);
＠＠ -3238,9 +3246,7 ＠＠
if (!byte_ascii_p (XSTRING_DATA (ss)[jj]))
break;
}
- XSET_STRING_ASCII_BEGIN (ss,
- min (jj,
- (Bytecount) MAX_STRING_ASCII_BEGIN));
+ XSET_STRING_ASCII_BEGIN (ss, jj);
}
}
sledgehammer_check_ascii_begin (ss);
＠＠ -3269,9 +3275,9 ＠＠
make_fixnum (STRING_BYTE_TOTAL_SIZE_LIMIT - 1));
val = make_uninit_string (XFIXNUM (length));
- memset (XSTRING_DATA (val), XCHAR (character), XSTRING_LENGTH (val));
- XSET_STRING_ASCII_BEGIN (val, min (MAX_STRING_ASCII_BEGIN,
- XSTRING_LENGTH (val)));
+ memset (XSTRING_DATA (val), XCHAR (character),
+ (size_t) XSTRING_LENGTH (val));
+ XSET_STRING_ASCII_BEGIN (val, XSTRING_LENGTH (val));
}
else if (FIXNUMP (length) && XREALFIXNUM (length) >= 0)
{
＠＠ -3304,7 +3310,7 ＠＠
val = make_uninit_string ((Bytecount) product);
ptr = XSTRING_DATA (val);
- for (i = clen; i; i--)
+ for (i = (EMACS_INT) clen; i; i--)
{
Ibyte *init_ptr = init_str;
switch (onelen)
＠＠ -3350,7 +3356,7 ＠＠
make_fixnum ((STRING_BYTE_TOTAL_SIZE_LIMIT - 1) /
MAX_ICHAR_LEN));
- storage = p = alloca_ibytes (nargs * MAX_ICHAR_LEN);
+ storage = p = alloca_ibytes ((size_t) nargs * MAX_ICHAR_LEN);
for (; nargs; nargs--, args++)
{
＠＠ -3400,10 +3406,9 ＠＠
if (!byte_ascii_p (contents[i]))
break;
}
- XSET_STRING_ASCII_BEGIN (string, min (i, MAX_STRING_ASCII_BEGIN));
+ XSET_STRING_ASCII_BEGIN (string, i);
#else
- XSET_STRING_ASCII_BEGIN (string, min (XSTRING_LENGTH (string),
- MAX_STRING_ASCII_BEGIN));
+ XSET_STRING_ASCII_BEGIN (string, XSTRING_LENGTH (string));
#endif
sledgehammer_check_ascii_begin (string);
}
＠＠ -3421,7 +3426,7 ＠＠
#endif
val = make_uninit_string (length);
- memcpy (XSTRING_DATA (val), contents, length);
+ memcpy (XSTRING_DATA (val), contents, (size_t) length);
init_string_ascii_begin (val);
sledgehammer_check_ascii_begin (val);
return val;
＠＠ -4196,7 +4201,7 ＠＠
const struct lrecord_header *h)
{
int type_index = h->type;
- int size = detagged_lisp_object_size (h);
+ Bytecount size = detagged_lisp_object_size (h);
lrecord_stats[type_index].instances_in_use--;
lrecord_stats[type_index].bytes_in_use -= size;
＠＠ -4206,11 +4211,11 ＠＠
DECREMENT_CONS_COUNTER (size);
}
-int
+Bytecount
lrecord_stats_heap_size (void)
{
int i;
- int size = 0;
+ Bytecount size = 0;
for (i = 0; i < countof (lrecord_implementations_table); i++)
size += lrecord_stats[i].bytes_in_use;
return size;
＠＠ -4395,7 +4400,7 ＠＠
static void
pluralize_word (Ascbyte *buf)
{
- Bytecount len = strlen (buf);
+ size_t len = strlen (buf);
int upper = 0;
Ascbyte d, e;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/array.c
--- a/src/array.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/array.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -308,16 +308,27 ＠＠
static void
Dynarr_realloc (Dynarr *dy, Elemcount new_size)
{
+ size_t bcount = (size_t) new_size * (size_t) (Dynarr_elsize (dy));
+
+ if ((bcount / (size_t) new_size) != (size_t) Dynarr_elsize (dy))
+ {
+ memory_full ();
+ }
+
if (DUMPEDP (dy->base))
{
- void *new_base = malloc (new_size * Dynarr_elsize (dy));
- memcpy (new_base, dy->base,
- (Dynarr_max (dy) < new_size ? Dynarr_max (dy) : new_size) *
- Dynarr_elsize (dy));
+ size_t copycount
+ = (size_t) (Dynarr_max (dy) < new_size ? Dynarr_max (dy) : new_size)
+ * (size_t) Dynarr_elsize (dy);
+ void *new_base = malloc (bcount);
+ memcpy (new_base, dy->base, copycount);
dy->base = new_base;
}
else
- dy->base = xrealloc (dy->base, new_size * Dynarr_elsize (dy));
+ {
+ malloc_checking_assert ((Bytecount) bcount >= 0);
+ dy->base = xrealloc (dy->base, bcount);
+ }
}
void *
＠＠ -407,28 +418,40 ＠＠
if (pos != old_len)
{
+ size_t bcount = (size_t) (old_len - pos) * (size_t) Dynarr_elsize (dy);
+ if ((bcount / (size_t) ((old_len - pos))) \
+ != (size_t) Dynarr_elsize (dy))
+ {
+ /* Overflow */
+ memory_full ();
+ }
memmove ((Rawbyte *) dy->base + (pos + len)*Dynarr_elsize (dy),
- (Rawbyte *) dy->base + pos*Dynarr_elsize (dy),
- (old_len - pos)*Dynarr_elsize (dy));
+ (Rawbyte *) dy->base + pos*Dynarr_elsize (dy), bcount);
}
/* Some functions call us with a value of 0 to mean "reserve space but
don't write into it" */
if (base)
- memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base,
- len*Dynarr_elsize (dy));
+ {
+ size_t bcount = (size_t) len * (size_t) (Dynarr_elsize (dy));
+ dynarr_checking_assert ((Bytecount) bcount >= 0);
+ memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base, bcount);
+ }
}
void
Dynarr_delete_many (void *d, Elemcount pos, Elemcount len)
{
Dynarr *dy = Dynarr_verify_mod (d);
+ size_t bcount
+ = (size_t) (Dynarr_length (dy) - pos - len) * (size_t) Dynarr_elsize (dy);
dynarr_checking_assert (pos >= 0 && len >= 0 &&
pos + len <= Dynarr_length (dy));
+ /* Not checking on overflow for BCOUNT because we're reducing the size
+ used, we had to have overflowed already. */
memmove ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy),
- (Rawbyte *) dy->base + (pos + len)*Dynarr_elsize (dy),
- (Dynarr_length (dy) - pos - len)*Dynarr_elsize (dy));
+ (Rawbyte *) dy->base + (pos + len)*Dynarr_elsize (dy), bcount);
Dynarr_set_length_1 (dy, Dynarr_length (dy) - len);
}
＠＠ -771,17 +794,21 ＠＠
if (pos < gap)
{
+ size_t bcount = (size_t) (gap - pos) * (size_t) (ga->elsize);
+ structure_checking_assert ((bcount / (size_t) (gap - pos))
+ == (size_t) (ga->elsize));
memmove (GAP_ARRAY_MEMEL_ADDR (ga, pos + gapsize),
- GAP_ARRAY_MEMEL_ADDR (ga, pos),
- (gap - pos)*ga->elsize);
+ GAP_ARRAY_MEMEL_ADDR (ga, pos), bcount);
gap_array_adjust_markers (ga, (Memxpos) pos, (Memxpos) gap,
gapsize);
}
else if (pos > gap)
{
+ size_t bcount = (size_t) (pos - gap) * (size_t) (ga->elsize);
+ structure_checking_assert ((bcount / (size_t) (pos - gap))
+ == (size_t) (ga->elsize));
memmove (GAP_ARRAY_MEMEL_ADDR (ga, gap),
- GAP_ARRAY_MEMEL_ADDR (ga, gap + gapsize),
- (pos - gap)*ga->elsize);
+ GAP_ARRAY_MEMEL_ADDR (ga, gap + gapsize), bcount);
gap_array_adjust_markers (ga, (Memxpos) (gap + gapsize),
(Memxpos) (pos + gapsize), - gapsize);
}
diff -r 046a3f85a39d -r c5889f9bb7f4 src/array.h
--- a/src/array.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/array.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -51,10 +51,10 ＠＠
type *base; \
DECLARE_DYNARR_LISP_IMP () \
DECLARE_DYNARR_LOCKED () \
- int elsize_; \
- int len_; \
- int largest_; \
- int max_
+ Bytecount elsize_; \
+ Elemcount len_; \
+ Elemcount largest_; \
+ Elemcount max_
typedef struct dynarr
{
＠＠ -152,7 +152,7 ＠＠
#ifdef ERROR_CHECK_DYNARR
DECLARE_INLINE_HEADER (
-int
+Elemcount
Dynarr_verify_pos_at (void *d, Elemcount pos, const Ascbyte *file, int line)
)
{
＠＠ -164,7 +164,7 ＠＠
}
DECLARE_INLINE_HEADER (
-int
+Elemcount
Dynarr_verify_pos_atp (void *d, Elemcount pos, const Ascbyte *file, int line)
)
{
＠＠ -204,7 +204,7 ＠＠
}
DECLARE_INLINE_HEADER (
-int
+Elemcount
Dynarr_verify_pos_atp_allow_end (void *d, Elemcount pos, const Ascbyte *file,
int line)
)
＠＠ -441,8 +441,9 ＠＠
)
{
Dynarr *dy = Dynarr_verify_mod (d);
- memset ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), 0,
- len*Dynarr_elsize (dy));
+ size_t bcount = (size_t) len * (size_t) (Dynarr_elsize (dy));
+
+ memset ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), 0, bcount);
}
/* This is an optimization. This is like Dynarr_set_length_and_zero() but
＠＠ -543,8 +544,10 ＠＠
Elemcount pos = Dynarr_length (dy);
Dynarr_increase_length (dy, Dynarr_length (dy) + len);
if (base)
- memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base,
- len*Dynarr_elsize (dy));
+ {
+ size_t bcount = (size_t) len * (size_t) Dynarr_elsize (dy);
+ memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base, bcount);
+ }
}
/* Insert LEN elements, currently pointed to by BASE, into dynarr D
＠＠ -606,7 +609,7 ＠＠
#define Dynarr_delete_object(d, el) \
do \
{ \
- REGISTER int _ddo_i; \
+ REGISTER Elemcount _ddo_i; \
for (_ddo_i = Dynarr_length (d) - 1; _ddo_i >= 0; _ddo_i--) \
{ \
if (el == Dynarr_at (d, _ddo_i)) \
＠＠ -767,7 +770,7 ＠＠
#ifdef NEW_GC
NORMAL_LISP_OBJECT_HEADER header;
#endif /* NEW_GC */
- int pos;
+ Elemcount pos;
struct gap_array_marker *next;
} Gap_Array_Marker;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/buffer.c
--- a/src/buffer.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/buffer.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -749,7 +749,7 ＠＠
/* For each slot that has a default value,
copy that into the slot. */
#define MARKED_SLOT(slot) \
- { int mask = XFIXNUM (buffer_local_flags.slot); \
+ { EMACS_INT mask = XFIXNUM (buffer_local_flags.slot); \
if ((mask > 0 || mask == -1 || mask == -3) \
&& (first_time \
|| NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \
＠＠ -811,7 +811,7 ＠＠
}
csize = XSTRING_LENGTH (name) + DECIMAL_PRINT_SIZE (EMACS_INT)
- + sizeof ("<>");
+ + (Bytecount) (sizeof ("<>"));
candidate = alloca_ibytes (csize);
count = itext_ichar_eql (XSTRING_DATA (name), ' ') ? get_random () : 1;
＠＠ -954,7 +954,7 ＠＠
{
struct buffer *syms = XBUFFER (Vbuffer_local_symbols);
#define MARKED_SLOT(slot) \
- { int mask = XFIXNUM (buffer_local_flags.slot); \
+ { EMACS_INT mask = XFIXNUM (buffer_local_flags.slot); \
if (mask == 0 || mask == -1 \
|| ((mask > 0) && (buf->local_var_flags & mask))) \
result = Fcons (Fcons (syms->slot, buf->slot), result); \
＠＠ -2221,8 +2221,8 ＠＠
MARK_LRECORD_AS_LISP_READONLY (I_hate_C); \
\
{ \
- int offset = ((char *)symbol_value_forward_forward (I_hate_C) - \
- (char *)&buffer_local_flags); \
+ ssize_t offset = ((char *)symbol_value_forward_forward (I_hate_C) - \
+ (char *)&buffer_local_flags); \
defvar_magic (lname, I_hate_C); \
\
*((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \
diff -r 046a3f85a39d -r c5889f9bb7f4 src/buffer.h
--- a/src/buffer.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/buffer.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -239,7 +239,7 ＠＠
/* Flags saying which DEFVAR_PER_BUFFER variables
are local to this buffer. */
- int local_var_flags;
+ EMACS_INT local_var_flags;
/* Set to the modtime of the visited file when read or written.
-1 means visited file was nonexistent.
diff -r 046a3f85a39d -r c5889f9bb7f4 src/bytecode.c
--- a/src/bytecode.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/bytecode.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -60,14 +60,16 ＠＠
#ifdef NEW_GC
static Lisp_Object
-make_compiled_function_args (int totalargs)
+make_compiled_function_args (Elemcount totalargs)
{
+ size_t bcount
+ = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Compiled_Function_Args,
+ Lisp_Object, args, (size_t) totalargs);
Lisp_Compiled_Function_Args *args;
+ structure_checking_assert ((Bytecount) bcount >= 0);
+
args = XCOMPILED_FUNCTION_ARGS
- (ALLOC_SIZED_LISP_OBJECT
- (FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Compiled_Function_Args,
- Lisp_Object, args, totalargs),
- compiled_function_args));
+ (ALLOC_SIZED_LISP_OBJECT ((Bytecount) bcount, compiled_function_args));
args->size = totalargs;
return wrap_compiled_function_args (args);
}
＠＠ -1470,7 +1472,7 ＠＠
const Opbyte *UNUSED (program_ptr),
Opcode opcode)
{
- REGISTER int n;
+ REGISTER EMACS_INT n;
switch (opcode)
{
diff -r 046a3f85a39d -r c5889f9bb7f4 src/callint.c
--- a/src/callint.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/callint.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -281,10 +281,10 ＠＠
#endif
/* If SPECS is a string, we reset prompt_data to XSTRING_DATA (specs)
every time a GC might have occurred */
- const char *prompt_data = 0;
- int prompt_index = 0;
+ const Ibyte *prompt_data = 0;
+ Bytecount prompt_index = 0;
int argcount;
- int set_zmacs_region_stays = 0;
+ Boolint set_zmacs_region_stays = 0;
int mouse_event_count = 0;
if (!NILP (keys))
＠＠ -316,7 +316,7 ＠＠
if (SUBRP (fun))
{
- prompt_data = XSUBR (fun)->prompt;
+ prompt_data = (const Ibyte *) XSUBR (fun)->prompt;
if (!prompt_data)
{
lose:
＠＠ -369,7 +369,7 ＠＠
if (!STRINGP (specs) && prompt_data == 0)
{
struct gcpro gcpro1, gcpro2, gcpro3;
- int i = num_input_chars;
+ Charcount i = num_input_chars;
Lisp_Object input = specs;
GCPRO3 (function, specs, input);
＠＠ -466,7 +466,7 ＠＠
for (;;)
{
if (STRINGP (specs))
- prompt_data = (const char *) XSTRING_DATA (specs);
+ prompt_data = (const Ibyte *) XSTRING_DATA (specs);
if (prompt_data[prompt_index] == '+')
syntax_error ("`+' is not used in `interactive' for ordinary commands", Qunbound);
＠＠ -527,7 +527,7 ＠＠
us give to the function. */
argcount = 0;
{
- const char *tem;
+ const Ibyte *tem;
for (tem = prompt_data + prompt_index; *tem; )
{
/* 'r' specifications ("point and mark as 2 numeric args")
＠＠ -536,7 +536,7 ＠＠
argcount += 2;
else
argcount += 1;
- tem = (const char *) strchr (tem + 1, '\n');
+ tem = qxestrchr (tem + 1, '\n');
if (!tem)
break;
tem++;
＠＠ -575,11 +575,11 ＠＠
{
/* args[-1] is the function to call */
/* args[n] is the n'th argument to the function */
- int alloca_size = (1 /* function to call */
- + argcount /* actual arguments */
- + argcount /* visargs */
- + argcount /* varies */
- );
+ Bytecount alloca_size = (1 /* function to call */
+ + argcount /* actual arguments */
+ + argcount /* visargs */
+ + argcount /* varies */
+ );
Lisp_Object *args = alloca_array (Lisp_Object, alloca_size) + 1;
/* visargs is an array of either Qnil or user-friendlier versions (often
* strings) of previous arguments, to use in prompts for successive
＠＠ -590,7 +590,7 ＠＠
its value in this call quoted in the command history. It should be
recorded as a call to the function named varies[i]]. */
Lisp_Object *varies = visargs + argcount;
- int arg_from_tty = 0;
+ Boolint arg_from_tty = 0;
REGISTER int argnum;
struct gcpro gcpro1, gcpro2;
＠＠ -606,12 +606,12 ＠＠
for (argnum = 0; ; argnum++)
{
- const char *prompt_start = prompt_data + prompt_index + 1;
- const char *prompt_limit = (const char *) strchr (prompt_start, '\n');
- int prompt_length;
+ const Ibyte *prompt_start = prompt_data + prompt_index + 1;
+ const Ibyte *prompt_limit = qxestrchr (prompt_start, '\n');
+ Bytecount prompt_length;
prompt_length = ((prompt_limit)
? (prompt_limit - prompt_start)
- : (int) strlen (prompt_start));
+ : qxestrlen (prompt_start));
if (prompt_limit && prompt_limit[1] == 0)
{
prompt_limit = 0; /* "sfoo:\n" -- strip tailing return */
＠＠ -933,7 +933,7 ＠＠
if (!prompt_limit)
break;
if (STRINGP (specs))
- prompt_data = (const char *) XSTRING_DATA (specs);
+ prompt_data = (const Ibyte *) XSTRING_DATA (specs);
prompt_index += prompt_length + 1 + 1; /* +1 to skip spec, +1 for \n */
}
unbind_to (speccount);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/casefiddle.c
--- a/src/casefiddle.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/casefiddle.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -68,7 +68,7 ＠＠
Ibyte *newp = storage;
Ibyte *oldp = XSTRING_DATA (string_or_char);
Ibyte *endp = oldp + XSTRING_LENGTH (string_or_char);
- int wordp = 0, wordp_prev;
+ Boolint wordp = 0, wordp_prev;
while (oldp < endp)
{
＠＠ -203,7 +203,7 ＠＠
Charbpos pos, s, e;
Lisp_Object syntax_table = BUFFER_MIRROR_SYNTAX_TABLE (buf);
int mccount;
- int wordp = 0, wordp_prev;
+ Boolint wordp = 0, wordp_prev;
if (EQ (start, end))
/* Not modifying because nothing marked */
diff -r 046a3f85a39d -r c5889f9bb7f4 src/charset.h
--- a/src/charset.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/charset.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -989,7 +989,7 ＠＠
to the Dynarr. FAIL controls failure mode when charset conversion to
Unicode is not possible. */
DECLARE_INLINE_HEADER (
-int
+Bytecount
charset_codepoint_to_dynarr (Lisp_Object charset, int c1, int c2,
unsigned_char_dynarr *dst,
enum converr USED_IF_MULE (fail))
diff -r 046a3f85a39d -r c5889f9bb7f4 src/chartab.c
--- a/src/chartab.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/chartab.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -269,7 +269,6 ＠＠
clone_chartab_table (Lisp_Object table, int level, int catp)
{
Lisp_Object newtab;
- Bytecount size;
check_chartab_invariants (table, level, catp);
＠＠ -280,10 +279,9 ＠＠
return table;
}
- size = sizeof (Lisp_Object);
newtab = ALLOCATE_LEVEL_N_SUBTAB ();
memcpy (SUBTAB_ARRAY_FROM_SUBTAB (newtab), SUBTAB_ARRAY_FROM_SUBTAB (table),
- 256 * size);
+ 256 * sizeof (Lisp_Object));
{
int i;
＠＠ -506,7 +504,7 ＠＠
int levels;
#ifndef MAXIMIZE_CHAR_TABLE_DEPTH
int code_levels;
- int catp = XCHAR_TABLE_CATEGORY_P (chartab);
+ Boolint catp = XCHAR_TABLE_CATEGORY_P (chartab);
#endif
/* DO NOT check to see whether START and END are valid Ichars. They
＠＠ -1217,8 +1215,6 ＠＠
range);
outrange->type = CHARTAB_RANGE_ROW;
outrange->charset = Fget_charset (elts[0]);
- CHECK_FIXNUM (elts[1]);
- outrange->row = XFIXNUM (elts[1]);
if (XCHARSET_DIMENSION (outrange->charset) == 1)
sferror ("Charset in row vector must be multi-byte",
outrange->charset);
＠＠ -1229,6 +1225,7 ＠＠
make_fixnum (XCHARSET_OFFSET (outrange->charset, 0) +
XCHARSET_CHARS (outrange->charset, 0) - 1));
}
+ outrange->row = (int) XFIXNUM (elts[1]);
}
else
{
diff -r 046a3f85a39d -r c5889f9bb7f4 src/cmds.c
--- a/src/cmds.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/cmds.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -170,7 +170,7 ＠＠
(count, buffer))
{
struct buffer *b = decode_buffer (buffer, 1);
- REGISTER int orig, end;
+ REGISTER Charbpos orig, end;
buffer = wrap_buffer (b);
if (NILP (count))
＠＠ -228,7 +228,7 ＠＠
}
return make_fixnum (find_before_next_newline (buf, BUF_PT (buf), 0,
- n - (n <= 0)));
+ n - (n <= 0)));
}
DEFUN ("end-of-line", Fend_of_line, 0, 2, "_p", /*
＠＠ -379,7 +379,7 ＠＠
Lisp_Object overwrite;
Lisp_Object syntax_table;
struct buffer *buf = current_buffer;
- int tab_width;
+ Charcount tab_width;
overwrite = buf->overwrite_mode;
syntax_table = BUFFER_MIRROR_SYNTAX_TABLE (buf);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/console.c
--- a/src/console.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/console.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -681,8 +681,9 ＠＠
*/
void
-delete_console_internal (struct console *con, int force,
- int called_from_kill_emacs, int from_io_error)
+delete_console_internal (struct console *con, Boolint force,
+ Boolint called_from_kill_emacs,
+ Boolint from_io_error)
{
/* This function can GC */
Lisp_Object console;
＠＠ -1115,10 +1116,10 ＠＠
(UNUSED (ignored), USED_IF_TTY (flow), meta, quit, console))
{
struct console *con = decode_console (console);
- int meta_key = (!CONSOLE_TTY_P (con) ? 1 :
- EQ (meta, Qnil) ? 0 :
- EQ (meta, Qt) ? 1 :
- 2);
+ unsigned int meta_key = (!CONSOLE_TTY_P (con) ? 1 :
+ EQ (meta, Qnil) ? 0 :
+ EQ (meta, Qt) ? 1 :
+ 2);
if (!NILP (quit))
{
＠＠ -1133,7 +1134,7 ＠＠
{
reset_one_console (con);
TTY_FLAGS (con).flow_control = !NILP (flow);
- TTY_FLAGS (con).meta_key = meta_key;
+ TTY_FLAGS (con).meta_key = meta_key & 0x2;
init_one_console (con);
MARK_FRAME_CHANGED (XFRAME (CONSOLE_SELECTED_FRAME (con)));
}
＠＠ -1337,7 +1338,7 ＠＠
MARK_LRECORD_AS_LISP_READONLY (I_hate_C); \
\
{ \
- int offset = ((char *)symbol_value_forward_forward (I_hate_C) \
+ size_t offset = ((char *)symbol_value_forward_forward (I_hate_C) \
- (char *)&console_local_flags); \
\
defvar_magic (lname, I_hate_C); \
diff -r 046a3f85a39d -r c5889f9bb7f4 src/console.h
--- a/src/console.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/console.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -138,8 +138,9 ＠＠
enum console_variant get_console_variant (Lisp_Object type);
-void delete_console_internal (struct console *con, int force,
- int from_kill_emacs, int from_io_error);
+void delete_console_internal (struct console *con, Boolint force,
+ Boolint from_kill_emacs,
+ Boolint from_io_error);
void io_error_delete_console (Lisp_Object console);
void set_console_last_nonminibuf_frame (struct console *con,
Lisp_Object frame);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/data.c
--- a/src/data.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/data.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -1200,7 +1200,8 ＠＠
type_checking_assert (FIXNUMP (top) && FIXNUMP (bot));
- return (XFIXNUM (top) << 16) | (XFIXNUM (bot) & 0xffff);
+ return ((UINT_32_BIT) XFIXNUM (top) << 16) |
+ (UINT_32_BIT) (XFIXNUM (bot) & 0xffff);
}
}
＠＠ -1237,7 +1238,7 ＠＠
return (INT_32_BIT) bignum_to_emacs_int (XBIGNUM_DATA (item));
}
#endif
- return XFIXNUM (item);
+ return (UINT_32_BIT) XFIXNUM (item);
}
else
{
＠＠ -2924,7 +2925,7 ＠＠
val2 = EMACS_INT_ABS (number2);
- return make_fixnum ((EMACS_INT)((val1 % val2) * sign));
+ return make_fixnum ((EMACS_INT)(val1 % val2) * sign);
}
DEFUN ("%", Frem, 2, 2, 0, /*
＠＠ -3146,7 +3147,7 ＠＠
{
args_out_of_range_3 (count,
make_bignum_ll (- (long long)(ULONG_MAX)),
- make_bignum_ll (ULONG_MAX));
+ make_bignum_ull (ULONG_MAX));
}
bignum_rshift (scratch_bignum2, XBIGNUM_DATA (value),
bignum_to_ulong (scratch_bignum));
＠＠ -3158,7 +3159,7 ＠＠
{
args_out_of_range_3 (count,
make_bignum_ll (- (long long) (ULONG_MAX)),
- make_bignum_ll (ULONG_MAX));
+ make_bignum_ull (ULONG_MAX));
}
bignum_lshift (scratch_bignum2, XBIGNUM_DATA (value),
bignum_to_ulong (XBIGNUM_DATA (count)));
diff -r 046a3f85a39d -r c5889f9bb7f4 src/debug.c
--- a/src/debug.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/debug.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -61,7 +61,7 ＠＠
if (op == X_LIST || op == X_ACTIVE || op == X_INIT || EQ (class_, Q##item)) \
{ \
if (op == X_ADD || op == X_DELETE || op == X_INIT) \
- active_debug_classes.item = flag; \
+ active_debug_classes.item = flag & 1; \
else if (op == X_LIST \
|| (op == X_ACTIVE && active_debug_classes.item)) \
retval = Fcons (Q##item, retval); \
diff -r 046a3f85a39d -r c5889f9bb7f4 src/device.c
--- a/src/device.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/device.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -621,7 +621,7 ＠＠
specify different global resources (there's a property on each X
server's root window that holds some resources); tough luck for the
moment. */
- int first = NILP (get_default_device (type));
+ Boolint first = NILP (get_default_device (type));
GCPRO3 (device, console, name);
＠＠ -778,9 +778,9 ＠＠
*/
void
-delete_device_internal (struct device *d, int force,
- int called_from_delete_console,
- int from_io_error)
+delete_device_internal (struct device *d, Boolint force,
+ Boolint called_from_delete_console,
+ Boolint from_io_error)
{
/* This function can GC */
struct console *c;
＠＠ -1031,7 +1031,8 ＠＠
*/
(device, rate))
{
- CHECK_FIXNUM (rate);
+ /* Nothing greater than 30 bits, please.*/
+ check_integer_range (rate, Qzero, make_fixnum (0x3fffffff));
DEVICE_BAUD_RATE (decode_device (device)) = XFIXNUM (rate);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/device.h
--- a/src/device.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/device.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -101,9 +101,9 ＠＠
void select_device_1 (Lisp_Object);
struct device *decode_device (Lisp_Object);
void handle_asynch_device_change (void);
-void delete_device_internal (struct device *d, int force,
- int called_from_delete_console,
- int from_io_error);
+void delete_device_internal (struct device *d, Boolint force,
+ Boolint called_from_delete_console,
+ Boolint from_io_error);
void io_error_delete_device (Lisp_Object device);
Lisp_Object find_nonminibuffer_frame_not_on_device (Lisp_Object device);
void set_device_selected_frame (struct device *d, Lisp_Object frame);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/doc.c
--- a/src/doc.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/doc.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -48,7 +48,7 ＠＠
{
Ibyte buf[DOC_MAX_FILENAME_LENGTH+1];
Ibyte *buffer = buf;
- int buffer_size = sizeof (buf) - 1, space_left;
+ Bytecount buffer_size = sizeof (buf) - 1, space_left;
Ibyte *from, *to;
REGISTER Ibyte *p = buffer;
Lisp_Object return_me;
＠＠ -82,7 +82,7 ＠＠
space_left = buffer_size - (p - buffer);
while (space_left > 0)
{
- int nread;
+ Bytecount nread;
nread = Lstream_read (XLSTREAM (instream), p, space_left);
if (nread < 0)
＠＠ -740,8 +740,8 ＠＠
{
int fd;
Ibyte buf[1024 + 1];
- REGISTER int filled;
- REGISTER int pos;
+ REGISTER Bytecount filled;
+ REGISTER OFF_T pos;
REGISTER Ibyte *p, *end;
Lisp_Object sym, fun, tem;
Ibyte *name;
＠＠ -987,7 +987,7 ＠＠
if (!NILP (Ffboundp (sym)))
{
- int doc = 0;
+ EMACS_INT doc = 0;
Lisp_Object fun = XSYMBOL (sym)->function;
if (CONSP (fun) &&
EQ (XCAR (fun), Qmacro))
＠＠ -1129,7 +1129,8 ＠＠
strdata = XSTRING_DATA (string);
strlength = XSTRING_LENGTH (string);
strp = strdata + idx;
- backslashp = (const Ibyte *) memchr (strp, '\\', strlength - idx);
+ backslashp = (const Ibyte *) memchr (strp, '\\',
+ max (strlength - idx, 0));
partlen = backslashp ? backslashp - strp : strlength - idx;
if (changed)
＠＠ -1159,7 +1160,7 ＠＠
idx += ichar_len ('[');
strp = strdata + idx;
- strp = (Ibyte *) memchr (strp, ']', strlength - idx);
+ strp = (Ibyte *) memchr (strp, ']', max (strlength - idx, 0));
if (!strp)
{
diff -r 046a3f85a39d -r c5889f9bb7f4 src/doprnt.c
--- a/src/doprnt.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/doprnt.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -610,7 +610,14 ＠＠
{
Bytecount size = ratio_size_in_base (XRATIO_DATA (number),
radixing), len;
- Ibyte *buffer = alloca_ibytes (size);
+ Ibyte *buffer;
+
+ if (size < 0)
+ {
+ out_of_memory ("cannot print supplied ratio", Qunbound);
+ }
+
+ buffer = alloca_ibytes (size);
len = ratio_to_string_1 (&buffer, size, XRATIO_DATA (number), radixing,
fixnum_to_char_table);
＠＠ -2404,6 +2411,10 ＠＠
}
size = bignum_size_decimal (XBIGNUM_DATA (obj));
+ if (size < 0)
+ {
+ out_of_memory ("cannot print bignum in decimal", Qunbound);
+ }
to_print = alloca_ibytes (size);
end = to_print + size;
＠＠ -2452,6 +2463,11 ＠＠
}
size = bignum_size_octal (XBIGNUM_DATA (obj));
+ if (size < 0)
+ {
+ out_of_memory ("cannot print bignum", Qunbound);
+ }
+
to_print = alloca_ibytes (size);
end = to_print + size;
＠＠ -2506,6 +2522,10 ＠＠
}
size = bignum_size_binary (XBIGNUM_DATA (obj));
+ if (size < 0)
+ {
+ out_of_memory ("cannot print bignum in binary", Qunbound);
+ }
to_print = alloca_ibytes (size);
end = to_print + size;
＠＠ -2559,6 +2579,10 ＠＠
}
size = bignum_size_hex (XBIGNUM_DATA (obj));
+ if (size < 0)
+ {
+ out_of_memory ("cannot print bignum in hex", Qunbound);
+ }
to_print = alloca_ibytes (size);
end = to_print + size;
＠＠ -2603,6 +2627,10 ＠＠
}
size = ratio_size_in_base (XRATIO_DATA (obj), 10);
+ if (size < 0)
+ {
+ out_of_memory ("cannot print ratio in decimal", Qunbound);
+ }
to_print = alloca_ibytes (size);
end = to_print + size;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/editfns.c
--- a/src/editfns.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/editfns.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -1651,7 +1651,7 ＠＠
REGISTER Bytecount charlen;
Ibyte str[MAX_ICHAR_LEN];
struct buffer *b = decode_buffer (buffer, 1);
- int cou;
+ Charcount cou;
CHECK_CHAR_COERCE_INT (character);
if (NILP (count))
＠＠ -2161,7 +2161,7 ＠＠
{
struct buffer *buf;
Lisp_Object markers = XCDR (data);
- int local_clip_changed = 0;
+ Boolint local_clip_changed = 0;
buf = XBUFFER (XCAR (data));
/* someone could have killed the buffer in the meantime ... */
diff -r 046a3f85a39d -r c5889f9bb7f4 src/elhash.c
--- a/src/elhash.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/elhash.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -2307,7 +2307,8 ＠＠
/* Return a hash value for an array of Lisp_Objects of size SIZE. */
Hashcode
-internal_array_hash (Lisp_Object *arr, int size, int depth, Boolint equalp)
+internal_array_hash (Lisp_Object *arr, Elemcount size, int depth,
+ Boolint equalp)
{
int i;
Hashcode hash = 0;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/filelock.c
--- a/src/filelock.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/filelock.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -89,7 +89,7 ＠＠
/* When we read the info back, we might need this much more,
enough for decimal representation plus null. */
-#define LOCK_PID_MAX (4 * sizeof (pid_t))
+#define LOCK_PID_MAX (4 * (int) (sizeof (pid_t)))
/* Free the two dynamically-allocated pieces in PTR. */
#define FREE_LOCK_INFO(i) do { \
＠＠ -109,7 +109,7 ＠＠
{
Ibyte *file_name = XSTRING_DATA (fn);
Ibyte *p;
- Bytecount dirlen;
+ size_t dirlen;
for (p = file_name + XSTRING_LENGTH (fn) - 1;
p > file_name && !IS_ANY_SEP (p[-1]);
＠＠ -173,11 +173,11 ＠＠
current_lock_owner (lock_info_type *owner, Ibyte *lfname)
{
/* Does not GC. */
- int len, ret;
- int local_owner = 0;
+ Bytecount len;
+ int local_owner = 0, ret;
Ibyte *at, *dot;
Ibyte *lfinfo = 0;
- int bufsize = 50;
+ size_t bufsize = 50;
/* Read arbitrarily-long contents of symlink. Similar code in
file-symlink-p in fileio.c. */
do
＠＠ -186,7 +186,7 ＠＠
lfinfo = (Ibyte *) xrealloc (lfinfo, bufsize);
len = qxe_readlink (lfname, lfinfo, bufsize);
}
- while (len >= bufsize);
+ while (len >= (Bytecount) bufsize);
/* If nonexistent lock file, all is well; otherwise, got strange error. */
if (len == -1)
diff -r 046a3f85a39d -r c5889f9bb7f4 src/indent.c
--- a/src/indent.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/indent.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -49,7 +49,7 ＠＠
Some things set last_known_column_point to -1
to mark the memoized value as invalid */
-static int last_known_column;
+static Charcount last_known_column;
/* Last buffer searched by current_column */
static struct buffer *last_known_column_buffer;
＠＠ -120,13 +120,13 ＠＠
last_known_column_point = -1;
}
-int
-column_at_point (struct buffer *buf, Charbpos init_pos, int cur_col)
+Charcount
+column_at_point (struct buffer *buf, Charbpos init_pos, Charcount cur_col)
{
- int col;
- int tab_seen;
- int tab_width = XFIXNUM (buf->tab_width);
- int post_tab;
+ Charcount col;
+ Charcount tab_seen;
+ Charcount tab_width = XFIXNUM (buf->tab_width);
+ Charcount post_tab;
Charbpos pos = init_pos;
Ichar c;
＠＠ -187,12 +187,12 ＠＠
return col;
}
-int
-string_column_at_point (Lisp_Object s, Charbpos init_pos, int tab_width)
+Charcount
+string_column_at_point (Lisp_Object s, Charbpos init_pos, Charcount tab_width)
{
- int col;
- int tab_seen;
- int post_tab;
+ Charcount col;
+ Charcount tab_seen;
+ Charcount post_tab;
Charbpos pos = init_pos;
Ichar c;
＠＠ -230,7 +230,7 ＠＠
return col;
}
-int
+Charcount
current_column (struct buffer *buf)
{
if (buf == last_known_column_buffer
＠＠ -268,10 +268,10 ＠＠
(column, minimum, buffer))
{
/* This function can GC */
- int mincol;
- int fromcol;
+ Charcount mincol;
+ Charcount fromcol;
struct buffer *buf = decode_buffer (buffer, 0);
- int tab_width = XFIXNUM (buf->tab_width);
+ Charcount tab_width = XFIXNUM (buf->tab_width);
Charbpos opoint = 0;
CHECK_FIXNUM (column);
＠＠ -305,7 +305,7 ＠＠
if (indent_tabs_mode)
{
- int n = mincol / tab_width - fromcol / tab_width;
+ Charcount n = mincol / tab_width - fromcol / tab_width;
if (n != 0)
{
Finsert_char (make_char ('\t'), make_fixnum (n), Qnil, buffer);
＠＠ -328,13 +328,13 ＠＠
return make_fixnum (mincol);
}
-int
+Charcount
byte_spaces_at_point (struct buffer *b, Bytebpos byte_pos)
{
Bytebpos byte_end = BYTE_BUF_ZV (b);
- int col = 0;
+ Charcount col = 0;
Ichar c;
- int tab_width = XFIXNUM (b->tab_width);
+ Charcount tab_width = XFIXNUM (b->tab_width);
if (tab_width <= 0 || tab_width > 1000)
tab_width = 8;
＠＠ -392,19 +392,26 ＠＠
/* This function can GC */
Charbpos pos;
struct buffer *buf = decode_buffer (buffer, 0);
- int col = current_column (buf);
- int goal;
+ Charcount col = current_column (buf);
+ Charcount goal;
Charbpos end;
- int tab_width = XFIXNUM (buf->tab_width);
+ Charcount tab_width = XFIXNUM (buf->tab_width);
- int prev_col = 0;
+ Charcount prev_col = 0;
Ichar c = 0;
buffer = wrap_buffer (buf);
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
- check_integer_range (column, Qzero, make_fixnum (MOST_POSITIVE_FIXNUM));
- goal = XFIXNUM (column);
+ CHECK_NATNUM (column);
+ if (BIGNUMP (column))
+ {
+ goal = 1 + MOST_POSITIVE_FIXNUM;
+ }
+ else
+ {
+ goal = XFIXNUM (column);
+ }
retry:
pos = BUF_PT (buf);
＠＠ -526,7 +533,7 ＠＠
{
Lisp_Object charbpos, hpos, vpos, prevhpos, contin;
struct position *pos;
- int hscroll, tab_offset;
+ Charcount hscroll, tab_offset;
struct window *w = decode_window (window);
CHECK_FIXNUM_COERCE_MARKER (from);
＠＠ -694,7 +701,7 ＠＠
{
Charbpos charbpos;
Charbpos orig;
- int selected;
+ Boolint selected;
int *vpos, *vpix;
int value=0;
struct window *w;
＠＠ -877,9 +884,9 ＠＠
{
Charbpos charbpos;
Charbpos orig;
- int selected;
+ Boolint selected;
int motion;
- int howto;
+ int howto = 0;
struct window *w;
if (NILP (window))
＠＠ -895,7 +902,19 ＠＠
orig = selected ? BUF_PT (XBUFFER (w->buffer))
: marker_position (w->pointm[CURRENT_DISP]);
- howto = FIXNUMP (how) ? XFIXNUM (how) : 0;
+ if (INTEGERP (how))
+ {
+ if (FIXNUMP (how))
+ {
+ howto = XFIXNUM (how) < 0 ? -1 : (XFIXNUM (how) > 0);
+ }
+#ifdef HAVE_BIGNUM
+ else
+ {
+ howto = bignum_sign (XBIGNUM_DATA (how));
+ }
+#endif
+ }
charbpos = vmotion_pixels (window, orig, XFIXNUM (pixels), howto, &motion);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/lisp-disunion.h
--- a/src/lisp-disunion.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/lisp-disunion.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -83,7 +83,7 ＠＠
#define XPNTRVAL(x) (x) /* This depends on Lisp_Type_Record == 0 */
/* A character is always >= 0, so get 30 bits out of it by treating it as
unsigned */
-#define XCHARVAL(x) ((EMACS_UINT)(x) >> GCBITS)
+#define XCHARVAL(x) ((EMACS_UINT)(x) >> (EMACS_UINT) GCBITS)
#define XREALFIXNUM(x) ((x) >> FIXNUM_GCBITS)
#define XUINT(x) ((EMACS_UINT)(x) >> FIXNUM_GCBITS)
diff -r 046a3f85a39d -r c5889f9bb7f4 src/lisp.h
--- a/src/lisp.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/lisp.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -1447,7 +1447,7 ＠＠
#ifdef USE_GCC_EXTENDED_EXPRESSION_SYNTAX
#define ALLOCA(size) \
- ({ Bytecount temp_alloca_size; \
+ ({ size_t temp_alloca_size; \
REGEX_MALLOC_CHECK (); \
temp_alloca_size = (size); \
temp_alloca_size > MAX_ALLOCA_VS_C_ALLOCA ? \
＠＠ -2848,7 +2848,7 ＠＠
/* WARNING: If you modify an existing string, you must call
bump_string_modiff() afterwards. */
#define XSET_STRING_ASCII_BEGIN(s, val) \
- ((void) (XSTRING (s)->u.v.ascii_begin = (val)))
+ ((void) (XSTRING (s)->u.v.ascii_begin = (val) & MAX_STRING_ASCII_BEGIN))
#define XSTRING_FORMAT(s) FORMAT_DEFAULT
#define XSTRING_MODIFFP(s) (XSTRING (s)->u.v.modiffp + 0)
＠＠ -3277,12 +3277,27 ＠＠
character. */
#define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x))
+#define XCHAR_OR_CHAR_INT(x) XCHAR_OR_CHAR_INT_1 (x, __FILE__, __LINE__)
+
DECLARE_INLINE_HEADER (
Ichar
-XCHAR_OR_CHAR_INT (Lisp_Object obj)
+XCHAR_OR_CHAR_INT_1 (Lisp_Object obj, const Ascbyte *file, int line)
)
{
- return CHARP (obj) ? XCHAR (obj) : XFIXNUM (obj);
+ if (CHARP (obj))
+ {
+ return XCHARVAL (obj);
+ }
+ if (FIXNUMP (obj))
+ {
+ EMACS_INT ival = XREALFIXNUM (obj);
+ if (valid_ichar_p (ival))
+ {
+ return (Ichar) ival;
+ }
+ }
+ assert_at_line (CHARP (obj) || CHAR_INTP (obj), file, line);
+ return (Ichar) -1;
}
/* Signal an error if CH is not a valid character or integer Lisp_Object.
＠＠ -3294,7 +3309,7 ＠＠
if (CHARP (x)) \
; \
else if (CHAR_INTP (x)) \
- x = make_char (XFIXNUM (x)); \
+ x = make_char ((Ichar) XREALFIXNUM (x)); \
else \
x = wrong_type_argument (Qcharacterp, x); \
} while (0)
＠＠ -4003,8 +4018,14 ＠＠
/* hashing */
/************************************************************************/
-/* #### for a 64-bit machine, we should substitute a prime just over 2^32 */
-#define GOOD_HASH 65599 /* prime number just over 2^16; Dragon book, p. 435 */
+#if SIZEOF_EMACS_INT < 8
+#define GOOD_HASH ((Hashcode) 65599) /* prime number just over 2^16;
+ Dragon book, p. 435 */
+
+#else
+#define GOOD_HASH ((Hashcode) 4294967311UL) /* prime number just over 2^32 */
+#endif
+
#define HASH2(a,b) (GOOD_HASH * (a) + (b))
#define HASH3(a,b,c) (GOOD_HASH * HASH2 (a,b) + (c))
#define HASH4(a,b,c,d) (GOOD_HASH * HASH3 (a,b,c) + (d))
＠＠ -4014,10 +4035,10 ＠＠
#define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h))
#define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i))
-#define LISP_HASH(obj) ((unsigned long) STORE_LISP_IN_VOID (obj))
+#define LISP_HASH(obj) ((Hashcode) STORE_LISP_IN_VOID (obj))
Hashcode memory_hash (const void *xv, Bytecount size);
Hashcode internal_hash (Lisp_Object obj, int depth, Boolint equalp);
-Hashcode internal_array_hash (Lisp_Object *arr, int size, int depth,
+Hashcode internal_array_hash (Lisp_Object *arr, Elemcount size, int depth,
Boolint equalp);
＠＠ -4075,7 +4096,7 ＠＠
{
struct gcpro *next;
const Lisp_Object *var; /* Address of first protected variable */
- int nvars; /* Number of consecutive protected variables */
+ Elemcount nvars; /* Number of consecutive protected variables */
#if defined (__cplusplus) && defined (ERROR_CHECK_GC)
/* Try to catch GCPRO without UNGCPRO, or vice-versa. G++ complains (at
least with sufficient numbers of warnings enabled, i.e. -Weffc++) if a
＠＠ -5632,10 +5653,10 ＠＠
EXFUN (Findent_to, 3);
EXFUN (Fvertical_motion, 3);
-int byte_spaces_at_point (struct buffer *, Bytebpos);
-int column_at_point (struct buffer *, Charbpos, int);
-int string_column_at_point (Lisp_Object, Charbpos, int);
-int current_column (struct buffer *);
+Charcount byte_spaces_at_point (struct buffer *, Bytebpos);
+Charcount column_at_point (struct buffer *, Charbpos, Charcount);
+Charcount string_column_at_point (Lisp_Object, Charbpos, Charcount);
+Charcount current_column (struct buffer *);
void invalidate_current_column (void);
Charbpos vmotion (struct window *, Charbpos, int, int *);
Charbpos vmotion_pixels (Lisp_Object, Charbpos, int, int, int *);
＠＠ -5654,7 +5675,7 ＠＠
if (*len < 0)
{
if (nonreloc)
- *len = strlen ((const Chbyte *) nonreloc) - offset;
+ *len = (Bytecount) strlen ((const Chbyte *) nonreloc) - offset;
else
*len = XSTRING_LENGTH (reloc) - offset;
}
＠＠ -5878,7 +5899,7 ＠＠
void debug_print (Lisp_Object);
void debug_p4 (Lisp_Object obj);
void debug_p3 (Lisp_Object obj);
-void debug_short_backtrace (int);
+void debug_short_backtrace (EMACS_INT);
void debug_backtrace (void);
MODULE_API Bytecount write_lisp_string (Lisp_Object stream, Lisp_Object string,
Bytecount offset, Bytecount len);
＠＠ -5899,7 +5920,8 ＠＠
{
/* This function can GC. We'd like to qxestrlen, but that's not yet
available in this file. */
- return write_string_1 (stream, str, strlen ((const char *) str));
+ return write_string_1 (stream, str,
+ (Bytecount) strlen ((const char *) str));
}
/* Same goes for this function. */
DECLARE_INLINE_HEADER (
＠＠ -5909,7 +5931,7 ＠＠
/* This function can GC. We'd like to qxestrlen, but that's not yet
available in this file. */
return write_string_1 (stream, (const Ibyte *) str,
- strlen ((const char *) str));
+ (Bytecount) strlen ((const char *) str));
}
/* Same goes for this function. */
DECLARE_INLINE_HEADER (
＠＠ -5917,7 +5939,8 ＠＠
)
{
/* This function can GC. */
- return write_string_1 (stream, (const Ibyte *) str, strlen ((char *) str));
+ return write_string_1 (stream, (const Ibyte *) str,
+ (Bytecount) strlen ((char *) str));
}
Bytecount write_eistring (Lisp_Object stream, const Eistring *ei);
＠＠ -6031,7 +6054,8 ＠＠
Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int);
Bytecount byte_find_next_ichar_in_string (Lisp_Object, Ichar, Bytecount,
EMACS_INT);
-Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int);
+Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos,
+ EMACS_INT);
struct re_pattern_buffer *compile_pattern (Lisp_Object pattern,
struct re_registers *regp,
Lisp_Object translate,
＠＠ -6125,7 +6149,7 ＠＠
extern Lisp_Object Vobarray;
/* Defined in syntax.c */
-Charbpos scan_words (struct buffer *, Charbpos, int);
+Charbpos scan_words (struct buffer *, Charbpos, EMACS_INT);
EXFUN (Fchar_syntax, 2);
EXFUN (Fforward_word, 2);
extern Lisp_Object Vstandard_syntax_table;
＠＠ -6287,7 +6311,7 ＠＠
DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Ibyte *s))
{
- return strlen ((const Chbyte *) s);
+ return (Bytecount) strlen ((const Chbyte *) s);
}
DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Ibyte *s))
＠＠ -6566,7 +6590,7 ＠＠
/* Defined in undo.c */
EXFUN (Fundo_boundary, 0);
-Lisp_Object truncate_undo_list (Lisp_Object, int, int);
+Lisp_Object truncate_undo_list (Lisp_Object, Fixnum, Fixnum);
void record_extent (Lisp_Object, int);
void record_insert (struct buffer *, Charbpos, Charcount);
void record_delete (struct buffer *, Charbpos, Charcount);
＠＠ -6732,7 +6756,7 ＠＠
/* This function can GC */
str = ASCGETTEXT (str);
write_string_1 (stream, (const Ibyte *) str,
- strlen ((const Ascbyte *) str));
+ (Bytecount) strlen ((const Ascbyte *) str));
}
#define write_msg_string write_msg_ascstring
diff -r 046a3f85a39d -r c5889f9bb7f4 src/lrecord.h
--- a/src/lrecord.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/lrecord.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -266,7 +266,7 ＠＠
SLI_header->type = (imp)->lrecord_type_index; \
SLI_header->lisp_readonly = 0; \
SLI_header->free = 0; \
- SLI_header->uid = lrecord_uid_counter[(imp)->lrecord_type_index]++; \
+ SLI_header->uid = lrecord_uid_counter[(imp)->lrecord_type_index]++; \
} while (0)
#else /* not NEW_GC */
#define set_lheader_implementation(header,imp) do { \
＠＠ -671,7 +671,7 ＠＠
void inc_lrecord_stats (Bytecount size, const struct lrecord_header *h);
void dec_lrecord_stats (Bytecount size_including_overhead,
const struct lrecord_header *h);
-int lrecord_stats_heap_size (void);
+Bytecount lrecord_stats_heap_size (void);
#endif /* ALLOC_TYPE_STATS */
/* Tell mc-alloc how to call a finalizer. */
＠＠ -2094,10 +2094,10 ＠＠
MODULE_API Lisp_Object alloc_lrecord (const struct lrecord_implementation *imp);
Lisp_Object noseeum_alloc_lrecord (const struct lrecord_implementation *imp);
-MODULE_API Lisp_Object alloc_lrecord_array (int elemcount,
+MODULE_API Lisp_Object alloc_lrecord_array (Elemcount elemcount,
const struct lrecord_implementation *imp);
MODULE_API Lisp_Object alloc_sized_lrecord_array (Bytecount size,
- int elemcount,
+ Elemcount elemcount,
const struct lrecord_implementation *imp);
#endif /* NEW_GC */
diff -r 046a3f85a39d -r c5889f9bb7f4 src/number.h
--- a/src/number.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/number.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -220,7 +220,7 ＠＠
NATNUMP. */
#ifdef HAVE_BIGNUM
-#define NATNUMP(x) ((FIXNUMP (x) && XFIXNUM (x) >= 0) || \
+#define NATNUMP(x) ((FIXNUMP (x) && XREALFIXNUM (x) >= 0) || \
(BIGNUMP (x) && bignum_sign (XBIGNUM_DATA (x)) >= 0))
#else
#define NATNUMP(x) (FIXNUMP (x) && XFIXNUM (x) >= 0)
diff -r 046a3f85a39d -r c5889f9bb7f4 src/print.c
--- a/src/print.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/print.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -2983,9 +2983,9 ＠＠
/* Do a "short" backtrace. */
void
-debug_short_backtrace (int length)
+debug_short_backtrace (EMACS_INT length)
{
- int first = 1;
+ Fixnum first = 1;
struct backtrace *bt = backtrace_list;
debug_out (" [");
diff -r 046a3f85a39d -r c5889f9bb7f4 src/search.c
--- a/src/search.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/search.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -924,7 +924,7 ＠＠
find_next_newline (...)-1, because you might hit TO. */
Charbpos
find_before_next_newline (struct buffer *buf, Charbpos from, Charbpos to,
- int count)
+ EMACS_INT count)
{
EMACS_INT shortage;
Charbpos pos = scan_buffer (buf, '\n', from, to, count, &shortage, 1);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/syntax.c
--- a/src/syntax.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/syntax.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -750,7 +750,7 ＠＠
COUNT negative means scan backward and stop at word beginning. */
Charbpos
-scan_words (struct buffer *buf, Charbpos from, int count)
+scan_words (struct buffer *buf, Charbpos from, EMACS_INT count)
{
Charbpos limit = count > 0 ? BUF_ZV (buf) : BUF_BEGV (buf);
Ichar ch0, ch1;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/syntax.h
--- a/src/syntax.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/syntax.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -142,7 +142,7 ＠＠
/* Return the syntax code for a particular character and mirror table. */
DECLARE_INLINE_HEADER (
-int
+EMACS_INT
SYNTAX_CODE (Lisp_Object table, Ichar c)
)
{
diff -r 046a3f85a39d -r c5889f9bb7f4 src/sysdep.c
--- a/src/sysdep.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/sysdep.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -204,7 +204,7 ＠＠
#ifdef NEED_SYNC_PROCESS_CODE /* #### Used only on super-ancient systems */
static void
-wait_for_termination (int pid)
+wait_for_termination (pid_t pid)
{
/* #### With the new improved SIGCHLD handling stuff, there is much
less danger of race conditions and some of the comments below
＠＠ -608,7 +608,7 ＠＠
#else /* not WIN32_NATIVE */
{
- int pid;
+ pid_t pid;
struct save_signal saved_handlers[5];
saved_handlers[0].code = SIGINT;
＠＠ -663,7 +663,7 ＠＠
{
#if defined (SIGTSTP)
{
- int pgrp = EMACS_GET_PROCESS_GROUP ();
+ pid_t pgrp = EMACS_GET_PROCESS_GROUP ();
EMACS_KILLPG (pgrp, SIGTSTP);
}
＠＠ -681,9 +681,9 ＠＠
void
sys_suspend_process (
#ifdef SIGTSTP
- int process
+ pid_t process
#else
- int UNUSED (process)
+ pid_t UNUSED (process)
#endif
)
{
＠＠ -929,7 +929,7 ＠＠
#if defined (FIOSSAIOOWN)
{ /* HPUX stuff */
- int owner = getpid ();
+ pid_t owner = getpid ();
int ioctl_status;
if (DEVICE_TTY_P (d))
{
＠＠ -2904,10 +2904,10 ＠＠
}
#if defined (HAVE_READLINK)
-int
+ssize_t
qxe_readlink (const Ibyte *path, Ibyte *buf, size_t bufsiz)
{
- int retval;
+ Bytecount retval;
Extbyte *pathout;
PATHNAME_CONVERT_OUT (path, pathout);
diff -r 046a3f85a39d -r c5889f9bb7f4 src/sysfile.h
--- a/src/sysfile.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/sysfile.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -383,7 +383,7 ＠＠
int qxe_access (const Ibyte *path, int mode);
int qxe_eaccess (const Ibyte *path, int mode);
int qxe_lstat (const Ibyte *path, struct stat *buf);
-int qxe_readlink (const Ibyte *path, Ibyte *buf, size_t bufsiz);
+ssize_t qxe_readlink (const Ibyte *path, Ibyte *buf, size_t bufsiz);
int qxe_fstat (int fd, struct stat *buf);
int qxe_stat (const Ibyte *path, struct stat *buf);
Ibyte *qxe_realpath (const Ibyte *path, Ibyte resolved_path [],
diff -r 046a3f85a39d -r c5889f9bb7f4 src/text.c
--- a/src/text.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/text.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -2678,8 +2678,8 ＠＠
return changedp ? newp - newdata : 0;
}
-int
-eifind_large_enough_buffer (int oldbufsize, int needed_size)
+Bytecount
+eifind_large_enough_buffer (Bytecount oldbufsize, Bytecount needed_size)
{
while (oldbufsize < needed_size)
{
diff -r 046a3f85a39d -r c5889f9bb7f4 src/text.h
--- a/src/text.h Sat Apr 21 16:49:20 2018 +0100
+++ b/src/text.h Mon Apr 23 13:43:40 2018 +0100
＠＠ -1047,9 +1047,9 ＠＠
)
{
if (dfc_coding_system_is_unicode (codesys))
- return sizeof (wchar_t) * wcslen ((wchar_t *) ptr);
+ return (Bytecount) (sizeof (wchar_t) * wcslen ((wchar_t *) ptr));
else
- return strlen ((char *) ptr);
+ return (Bytecount) strlen ((char *) ptr);
}
＠＠ -1331,9 +1331,8 ＠＠
#ifdef ERROR_CHECK_TEXT
#define ASSERT_ASCTEXT_ASCII_LEN(ptr, len) \
do { \
- int aia2; \
+ size_t aia2, aia2len = (len); \
const Ascbyte *aia2ptr = (ptr); \
- int aia2len = (len); \
\
for (aia2 = 0; aia2 < aia2len; aia2++) \
assert (aia2ptr[aia2] >= 0x00 && aia2ptr[aia2] < 0x7F); \
＠＠ -2694,7 +2693,7 ＠＠
Bytecount max_size_allocated_;
Bytecount bytelen_;
Charcount charlen_;
- int mallocp_;
+ Boolint mallocp_;
Extbyte *extdata_;
Bytecount extlen_;
＠＠ -2757,17 +2756,17 ＠＠
#define EI_ALLOC(ei, newbytelen, newcharlen, newz) \
do { \
- int ei1oldeibytelen = (ei)->bytelen_; \
+ Bytecount ei1oldeibytelen = (ei)->bytelen_; \
\
(ei)->charlen_ = (newcharlen); \
(ei)->bytelen_ = (newbytelen); \
\
if (ei1oldeibytelen != (ei)->bytelen_) \
{ \
- int ei1newsize = (ei)->max_size_allocated_; \
+ Bytecount ei1newsize = (ei)->max_size_allocated_; \
while (ei1newsize < (ei)->bytelen_ + 1) \
{ \
- ei1newsize = (int) (ei1newsize * 1.5); \
+ ei1newsize = (Bytecount) (ei1newsize * 1.5); \
if (ei1newsize < 32) \
ei1newsize = 32; \
} \
＠＠ -2816,13 +2815,13 ＠＠
#define eicpy_lstr_off(ei, lisp_string, off, charoff, len, charlen) \
do { \
Lisp_Object ei23lstr = (lisp_string); \
- int ei23off = (off); \
- int ei23charoff = (charoff); \
- int ei23len = (len); \
- int ei23charlen = (charlen); \
+ Bytecount ei23off = (off); \
+ Charcount ei23charoff = (charoff); \
+ Bytecount ei23len = (len); \
+ Charcount ei23charlen = (charlen); \
const Ibyte *ei23data = XSTRING_DATA (ei23lstr); \
\
- int ei23oldbytelen = (ei)->bytelen_; \
+ Bytecount ei23oldbytelen = (ei)->bytelen_; \
\
eifixup_byte (ei23data, ei23off, ei23charoff); \
eifixup_bytechar (ei23data + ei23off, ei23len, ei23charlen); \
＠＠ -2834,7 +2833,7 ＠＠
do { \
const Ibyte *ei12ptr = (ptr); \
Internal_Format ei12fmt = (fmt); \
- int ei12len = (len); \
+ Bytecount ei12len = (len); \
assert (ei12fmt == FORMAT_DEFAULT); \
EI_ALLOC_AND_COPY (ei, ei12ptr, ei12len, \
bytecount_to_charcount (ei12ptr, ei12len)); \
＠＠ -2871,7 +2870,7 ＠＠
#define eicpy_ascii_len(ei, ascstr, c_len) \
do { \
const Ascbyte *ei6 = (ascstr); \
- int ei6len = (c_len); \
+ Bytecount ei6len = (c_len); \
\
ASSERT_ASCTEXT_ASCII_LEN (ei6, ei6len); \
eicpy_ext_len (ei, ei6, ei6len, Qbinary); \
＠＠ -2880,7 +2879,7 ＠＠
#define eicpy_ext_len(ei, extdata, extlen, codesys) \
do { \
const Extbyte *ei7 = (extdata); \
- int ei7len = (extlen); \
+ Bytecount ei7len = (extlen); \
\
TO_INTERNAL_FORMAT (DATA, (ei7, ei7len), \
ALLOCA, ((ei)->data_, (ei)->bytelen_), \
＠＠ -2914,10 +2913,10 ＠＠
#define eimake_string_off(eistr, off, charoff, len, charlen) \
do { \
Lisp_Object ei24lstr; \
- int ei24off = (off); \
- int ei24charoff = (charoff); \
- int ei24len = (len); \
- int ei24charlen = (charlen); \
+ Bytecount ei24off = (off); \
+ Charcount ei24charoff = (charoff); \
+ Bytecount ei24len = (len); \
+ Charcount ei24charlen = (charlen); \
\
eifixup_byte ((eistr)->data_, ei24off, ei24charoff); \
eifixup_byte ((eistr)->data_ + ei24off, ei24len, ei24charlen); \
＠＠ -2966,7 +2965,8 ＠＠
eiinit (ei); \
} while (0)
-int eifind_large_enough_buffer (int oldbufsize, int needed_size);
+Bytecount eifind_large_enough_buffer (Bytecount oldbufsize,
+ Bytecount needed_size);
void eito_malloc_1 (Eistring *ei);
#define eito_malloc(ei) eito_malloc_1 (ei)
＠＠ -3044,7 +3044,7 ＠＠
Charcount n))
{
Ibyte *pos = eistr->data_ + bytepos;
- int i;
+ Charcount i;
text_checking_assert (bytepos >= 0 && bytepos <= eistr->bytelen_);
text_checking_assert (n >= 0 && n <= eistr->charlen_);
＠＠ -3078,12 +3078,12 ＠＠
#define eicat_1(ei, data, bytelen, charlen) \
do { \
- int ei14oldeibytelen = (ei)->bytelen_; \
- int ei14bytelen = (bytelen); \
+ Bytecount ei14oldeibytelen = (ei)->bytelen_; \
+ Bytecount ei14bytelen = (bytelen); \
EI_ALLOC (ei, (ei)->bytelen_ + ei14bytelen, \
(ei)->charlen_ + (charlen), 1); \
memcpy ((ei)->data_ + ei14oldeibytelen, (data), \
- ei14bytelen); \
+ (size_t) ei14bytelen); \
} while (0)
#define eicat_ei(ei, ei2) \
＠＠ -3095,16 +3095,17 ＠＠
#define eicat_ascii(ei, ascstr) \
do { \
const Ascbyte *ei15 = (ascstr); \
- int ei15len = strlen (ei15); \
+ size_t ei15len = strlen (ei15); \
\
ASSERT_ASCTEXT_ASCII_LEN (ei15, ei15len); \
eicat_1 (ei, ei15, ei15len, \
- bytecount_to_charcount ((Ibyte *) ei15, ei15len)); \
+ bytecount_to_charcount ((Ibyte *) ei15, \
+ (Bytecount) ei15len)); \
} while (0)
#define eicat_raw(ei, data, len) \
do { \
- int ei16len = (len); \
+ Bytecount ei16len = (len); \
const Ibyte *ei16data = (data); \
eicat_1 (ei, ei16data, ei16len, \
bytecount_to_charcount (ei16data, ei16len)); \
＠＠ -3139,15 +3140,15 ＠＠
#define eisub_1(ei, off, charoff, len, charlen, src, srclen, srccharlen) \
do { \
- int ei18off = (off); \
- int ei18charoff = (charoff); \
- int ei18len = (len); \
- int ei18charlen = (charlen); \
+ Bytecount ei18off = (off); \
+ Charcount ei18charoff = (charoff); \
+ Bytecount ei18len = (len); \
+ Charcount ei18charlen = (charlen); \
Ibyte *ei18src = (Ibyte *) (src); \
- int ei18srclen = (srclen); \
- int ei18srccharlen = (srccharlen); \
+ Bytecount ei18srclen = (srclen); \
+ Charcount ei18srccharlen = (srccharlen); \
\
- int ei18oldeibytelen = (ei)->bytelen_; \
+ Bytecount ei18oldeibytelen = (ei)->bytelen_; \
\
eifixup_bytechar ((ei)->data_, ei18off, ei18charoff); \
eifixup_bytechar ((ei)->data_ + ei18off, ei18len, ei18charlen); \
＠＠ -3174,7 +3175,7 ＠＠
#define eisub_ascii(ei, off, charoff, len, charlen, ascstr) \
do { \
const Ascbyte *ei20 = (ascstr); \
- int ei20len = strlen (ei20); \
+ Bytecount ei20len = (Bytecount) strlen (ei20); \
ASSERT_ASCTEXT_ASCII_LEN (ei20, ei20len); \
eisub_1 (ei, off, charoff, len, charlen, ei20, ei20len, -1); \
} while (0)
＠＠ -3315,8 +3316,9 ＠＠
int ei11new_allocmax = (ei)->charlen_ * MAX_ICHAR_LEN + 1; \
Ibyte *ei11storage = \
(Ibyte *) alloca_ibytes (ei11new_allocmax); \
- int ei11newlen = eistr_casefiddle_1 ((ei)->data_, (ei)->bytelen_, \
- ei11storage, downp); \
+ Bytecount ei11newlen = eistr_casefiddle_1 ((ei)->data_, \
+ (ei)->bytelen_, \
+ ei11storage, downp); \
\
if (ei11newlen) \
{ \
diff -r 046a3f85a39d -r c5889f9bb7f4 src/undo.c
--- a/src/undo.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/undo.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -250,10 +250,10 ＠＠
undo-high-threshold. */
Lisp_Object
-truncate_undo_list (Lisp_Object list, int minsize, int maxsize)
+truncate_undo_list (Lisp_Object list, Fixnum minsize, Fixnum maxsize)
{
Lisp_Object prev, next, last_boundary;
- int size_so_far = 0;
+ Fixnum size_so_far = 0;
if (!(minsize > 0 || maxsize > 0))
return list;
diff -r 046a3f85a39d -r c5889f9bb7f4 src/unicode.c
--- a/src/unicode.c Sat Apr 21 16:49:20 2018 +0100
+++ b/src/unicode.c Mon Apr 23 13:43:40 2018 +0100
＠＠ -1644,7 +1644,8 ＠＠
write_ascstring (printcharfun,
"#<INTERNAL OBJECT (XEmacs bug?) (precedence-array)");
- write_fmt_string (printcharfun, " length=%d", Dynarr_length (data->precdyn));
+ write_fmt_string (printcharfun, " length=%ld",
+ Dynarr_length (data->precdyn));
for (i = 0; i < Dynarr_length (data->precdyn); i++)
{
Lisp_Object charset = Dynarr_at (data->precdyn, i);
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Reduce narrowing warnings, catch non-idempotent arguments to make_integer()
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524318697 -3600
# Sat Apr 21 14:51:37 2018 +0100
# Node ID 368318a5c386b0bce05209874e3241e3880e6ee2
# Parent 1df45726e0d6d45a816063328bd8e85c7ba701cc
Reduce narrowing warnings, catch non-idempotent arguments to make_integer()
src/ChangeLog addition:
2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
* lisp.h (NUMBER_FITS_IN_A_FIXNUM, NUMBER_FITS_IN_A_FIXNUM):
* number.h (make_integer, make_unsigned_integer):
If the GCC extended expression syntax is available, use it and
__typeof__ to catch non-idempotent arguments to these arguments,
and to silence type-narrowing warnings for non-EMACS_INT
arguments.
diff -r 1df45726e0d6 -r 368318a5c386 src/ChangeLog
--- a/src/ChangeLog Sat Apr 21 14:14:56 2018 +0100
+++ b/src/ChangeLog Sat Apr 21 14:51:37 2018 +0100
＠＠ -1,3 +1,12 ＠＠
+2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * lisp.h (NUMBER_FITS_IN_A_FIXNUM, NUMBER_FITS_IN_A_FIXNUM):
+ * number.h (make_integer, make_unsigned_integer):
+ If the GCC extended expression syntax is available, use it and
+ __typeof__ to catch non-idempotent arguments to these arguments,
+ and to silence type-narrowing warnings for non-EMACS_INT
+ arguments.
+
2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
* gccache-x.c (gc_cache_hash):
diff -r 1df45726e0d6 -r 368318a5c386 src/lisp.h
--- a/src/lisp.h Sat Apr 21 14:14:56 2018 +0100
+++ b/src/lisp.h Sat Apr 21 14:51:37 2018 +0100
＠＠ -1810,11 +1810,26 ＠＠
#define MOST_POSITIVE_FIXNUM ((EMACS_INT) MOST_POSITIVE_FIXNUM_UNSIGNED)
#define MOST_NEGATIVE_FIXNUM (-(MOST_POSITIVE_FIXNUM) - 1)
/* WARNING: evaluates its arg twice. */
+#ifdef USE_GCC_EXTENDED_EXPRESSION_SYNTAX
+#define NUMBER_FITS_IN_A_FIXNUM(num) \
+ ({ __typeof__ (num) _num = (num); \
+ assert (_num == num); /* Catch any non-idempotent argument. */ \
+ (((__typeof__ (num))-1 < 0) ? /* Signed? */ \
+ ((sizeof (_num) * BITS_PER_CHAR) <= FIXNUM_VALBITS || \
+ (((__typeof__ (num)) MOST_NEGATIVE_FIXNUM <= _num) && \
+ _num <= ((__typeof__ (num)) MOST_POSITIVE_FIXNUM))) \
+ : ((sizeof (_num) * BITS_PER_CHAR) < FIXNUM_VALBITS || \
+ (((__typeof__ (num)) 0 <= _num) && \
+ _num <= ((__typeof__ (num)) MOST_POSITIVE_FIXNUM)))); })
+#define UNSIGNED_NUMBER_FITS_IN_A_FIXNUM(num) \
+ ((num) <= (__typeof__ (num)) MOST_POSITIVE_FIXNUM_UNSIGNED)
+#else
#define NUMBER_FITS_IN_A_FIXNUM(num) \
((num) <= MOST_POSITIVE_FIXNUM && (num) >= MOST_NEGATIVE_FIXNUM)
#define UNSIGNED_NUMBER_FITS_IN_A_FIXNUM(num) \
((num) <= MOST_POSITIVE_FIXNUM_UNSIGNED)
+#endif
#ifdef USE_UNION_TYPE
# include "lisp-union.h"
#else /* !USE_UNION_TYPE */
diff -r 1df45726e0d6 -r 368318a5c386 src/number.h
--- a/src/number.h Sat Apr 21 14:14:56 2018 +0100
+++ b/src/number.h Sat Apr 21 14:51:37 2018 +0100
＠＠ -172,7 +172,18 ＠＠
} while (0)
#ifdef HAVE_BIGNUM
-#define make_integer(x) \
+#ifdef USE_GCC_EXTENDED_EXPRESSION_SYNTAX
+#define make_integer(x) \
+ ({ __typeof__ (x) _x = (x); \
+ assert (x == _x); /* Catch non-idempotent arguments. */ \
+ (NUMBER_FITS_IN_A_FIXNUM (_x) ? make_fixnum (_x) : \
+ (((__typeof__ (x))-1 < 0) ? \
+ (sizeof (_x) > SIZEOF_LONG ? make_bignum_ll (_x) : make_bignum (_x)) \
+ : (sizeof (_x) > SIZEOF_LONG ? make_bignum_ull (_x) \
+ : make_bignum_un (_x)))); })
+#define make_unsigned_integer make_integer
+#else
+#define make_integer(x) \
(NUMBER_FITS_IN_A_FIXNUM (x) ? make_fixnum (x) \
: (sizeof (x) > SIZEOF_LONG ? make_bignum_ll (x) : \
make_bignum ((long) x)))
＠＠ -180,6 +191,7 ＠＠
(UNSIGNED_NUMBER_FITS_IN_A_FIXNUM (x) ? make_fixnum (x) \
: (sizeof (x) > SIZEOF_LONG ? make_bignum_ull (x) : \
make_bignum_un ((unsigned long) x)))
+#endif /* USE_GCC_EXTENDED_EXPRESSION_SYNTAX */
#else
#define make_integer(x) make_fixnum (x)
#define make_unsigned_integer(x) make_fixnum ((EMACS_INT) x)
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Fix the build with g++ 6.
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1524316496 -3600
# Sat Apr 21 14:14:56 2018 +0100
# Node ID 1df45726e0d6d45a816063328bd8e85c7ba701cc
# Parent 78f89a29541b08276b6c8f4c4fca00e2fb6ab7eb
Fix the build with g++ 6.
src/ChangeLog addition:
2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
* gccache-x.c (gc_cache_hash):
* gccache-x.c (x_gc_cache_lookup):
Add a couple of casts here to placate the C++ compiler.
* text.c (rep_bytes_by_first_byte):
Don't use hexadecimal notation for 0xDEADBEEF in this table,
that causes a compile problem with C++ on a thirty-two bit
machine.
diff -r 78f89a29541b -r 1df45726e0d6 src/ChangeLog
--- a/src/ChangeLog Mon Apr 16 09:39:19 2018 +0100
+++ b/src/ChangeLog Sat Apr 21 14:14:56 2018 +0100
＠＠ -1,3 +1,13 ＠＠
+2018-04-21 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * gccache-x.c (gc_cache_hash):
+ * gccache-x.c (x_gc_cache_lookup):
+ Add a couple of casts here to placate the C++ compiler.
+ * text.c (rep_bytes_by_first_byte):
+ Don't use hexadecimal notation for 0xDEADBEEF in this table,
+ that causes a compile problem with C++ on a thirty-two bit
+ machine.
+
2018-04-16 Aidan Kehoe <kehoea(a)parhasard.net>
* fileio.c (Finsert_file_contents_internal):
diff -r 78f89a29541b -r 1df45726e0d6 src/gccache-x.c
--- a/src/gccache-x.c Mon Apr 16 09:39:19 2018 +0100
+++ b/src/gccache-x.c Sat Apr 21 14:14:56 2018 +0100
＠＠ -70,7 +70,8 ＠＠
static Hashcode
gc_cache_hash (const Hash_Table_Test * UNUSED (http), Lisp_Object arg)
{
- const struct gcv_and_mask *gcvm = GET_VOID_FROM_LISP (arg);
+ const struct gcv_and_mask *gcvm
+ = (const struct gcv_and_mask *) GET_VOID_FROM_LISP (arg);
EMACS_UINT *longs = (EMACS_UINT *) &gcvm->gcv;
Hashcode hash = gcvm->mask;
unsigned i;
＠＠ -218,7 +219,7 ＠＠
e = find_htentry (STORE_VOID_IN_LISP (&gcvm), XHASH_TABLE (cache->table));
if (!HTENTRY_CLEAR_P (e))
{
- cell = GET_VOID_FROM_LISP (e->value);
+ cell = (struct gc_cache_cell *) GET_VOID_FROM_LISP (e->value);
/* Found a cell. */
#ifdef DEBUG_GC_CACHE
diff -r 78f89a29541b -r 1df45726e0d6 src/text.c
--- a/src/text.c Mon Apr 16 09:39:19 2018 +0100
+++ b/src/text.c Sat Apr 21 14:14:56 2018 +0100
＠＠ -1285,23 +1285,40 ＠＠
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- /* 0x80 - 0xbf are not valid first bytes */
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
- 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF,
+ /* 0x80 - 0xbf are not valid first bytes. A bare 0xDEADBEEF or
+ DEADBEEF_CONSTANT without the cast runs foul of the C++ compiler. */
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT),
/* 0xc0 - 0xdf for 2-byte sequences */
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
＠＠ -1312,7 +1329,8 ＠＠
0xfc - 0xfd for 6-byte sequences;
0xfe, 0xff not allowed
*/
- 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0xDEADBEEF, 0xDEADBEEF
+ 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6,
+ (Bytecount) (DEADBEEF_CONSTANT), (Bytecount) (DEADBEEF_CONSTANT)
};
#else
/* #### Maybe this table should be derived programmatically, at least
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Quiet some compiler warnings, src/
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1523867959 -3600
# Mon Apr 16 09:39:19 2018 +0100
# Node ID 78f89a29541b08276b6c8f4c4fca00e2fb6ab7eb
# Parent fddc26a4bf701ec3b4d7c9d855e4ab41788d32f5
Quiet some compiler warnings, src/
src/ChangeLog addition:
2018-04-16 Aidan Kehoe <kehoea(a)parhasard.net>
* fileio.c (Finsert_file_contents_internal):
Be clearer about not using an unitialised OFFSET in an lseek(2)
call here.
* regex.c (re_wctype):
Match the argument types used in the declaration in regex.h, to
placate the C++ compiler.
* text.c:
Only make unicode_internal_handle_bad_ichar_to_unicode() available
on unicode-internal builds.
* tls.h (tls_negotiate):
Rework this stub macro to mark its arguments as used.
* vdb.c (Ftest_vdb):
Quiet the compiler regarding one variable here.
diff -r fddc26a4bf70 -r 78f89a29541b src/ChangeLog
--- a/src/ChangeLog Tue Apr 10 13:54:31 2018 +0100
+++ b/src/ChangeLog Mon Apr 16 09:39:19 2018 +0100
＠＠ -1,3 +1,19 ＠＠
+2018-04-16 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * fileio.c (Finsert_file_contents_internal):
+ Be clearer about not using an unitialised OFFSET in an lseek(2)
+ call here.
+ * regex.c (re_wctype):
+ Match the argument types used in the declaration in regex.h, to
+ placate the C++ compiler.
+ * text.c:
+ Only make unicode_internal_handle_bad_ichar_to_unicode() available
+ on unicode-internal builds.
+ * tls.h (tls_negotiate):
+ Rework this stub macro to mark its arguments as used.
+ * vdb.c (Ftest_vdb):
+ Quiet the compiler regarding one variable here.
+
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* config.h.in:
diff -r fddc26a4bf70 -r 78f89a29541b src/fileio.c
--- a/src/fileio.c Tue Apr 10 13:54:31 2018 +0100
+++ b/src/fileio.c Mon Apr 16 09:39:19 2018 +0100
＠＠ -3231,14 +3231,7 ＠＠
where it should be. */
|| (!NILP (replace) && do_speedy_insert))
{
- OFF_T starting;
-
- if (NUMBERP (start))
- {
- starting = lisp_to_off_t (start);
- }
-
- if (lseek (fd, starting, 0) < 0)
+ if (lseek (fd, lisp_to_off_t (start), 0) < 0)
report_file_error ("Setting file position", filename);
}
diff -r fddc26a4bf70 -r 78f89a29541b src/regex.c
--- a/src/regex.c Tue Apr 10 13:54:31 2018 +0100
+++ b/src/regex.c Mon Apr 16 09:39:19 2018 +0100
＠＠ -2211,7 +2211,7 ＠＠
Return RECC_ERROR if STRP doesn't match a known character class. */
re_wctype_t
-re_wctype (const re_char *beg, int limit)
+re_wctype (const unsigned char *beg, int limit)
{
/* Sort tests in the length=five case by frequency the classes to minimize
number of times we fail the comparison. The frequencies of character class
diff -r fddc26a4bf70 -r 78f89a29541b src/text.c
--- a/src/text.c Tue Apr 10 13:54:31 2018 +0100
+++ b/src/text.c Mon Apr 16 09:39:19 2018 +0100
＠＠ -1857,7 +1857,7 ＠＠
return -1;
}
-#endif /* not UNICODE_INTERNAL */
+#else /* if defined (UNICODE_INTERNAL) */
int
unicode_internal_handle_bad_ichar_to_unicode (Ichar chr, enum converr fail)
＠＠ -1892,6 +1892,8 ＠＠
}
}
+#endif /* defined (UNICODE_INTERNAL) */
+
#endif /* MULE */
/* Take a possibly invalid Ichar value (must be >= 0) and move upwards as
diff -r fddc26a4bf70 -r 78f89a29541b src/tls.h
--- a/src/tls.h Tue Apr 10 13:54:31 2018 +0100
+++ b/src/tls.h Mon Apr 16 09:39:19 2018 +0100
＠＠ -82,7 +82,8 ＠＠
#define TLS_SETUP_SOCK 1
#define tls_open(x,y) (signal_error (Qtls_error, "TLS support unavailable", \
Qnil), (tls_state_t *) NULL)
-#define tls_negotiate(x,y,z) ((tls_state_t *) NULL)
+#define tls_negotiate(x,y,z) (USED (x), USED (y), USED (z), \
+ (tls_state_t *) NULL)
#define make_tls_input_stream(x) (signal_error (Qtls_error, \
"TLS support unavailable", \
Qnil), Qnil)
diff -r fddc26a4bf70 -r 78f89a29541b src/vdb.c
--- a/src/vdb.c Tue Apr 10 13:54:31 2018 +0100
+++ b/src/vdb.c Mon Apr 16 09:39:19 2018 +0100
＠＠ -98,6 +98,7 ＠＠
fprintf (stderr, "Attempt to read p[666]... ");
c = p[666];
fprintf (stderr, "read ok.\n");
+ USED (c); /* Quiet compiler. */
/* Test write. */
fprintf (stderr, "Attempt to write 42 to p[666]... ");
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Don't use wcwidth() in #'char-width, it's not reliable.
6 years, 5 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1523364871 -3600
# Tue Apr 10 13:54:31 2018 +0100
# Node ID fddc26a4bf701ec3b4d7c9d855e4ab41788d32f5
# Parent b2979b81a38663cd670146fe85967107dbe9d1eb
Don't use wcwidth() in #'char-width, it's not reliable.
src/ChangeLog addition:
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* config.h.in:
No need for HAVE_WCWIDTH anymore.
* unicode.c (unicode_char_columns):
Don't ever use wcwidth() in this function, it's not
reliable, and this gives test failures with
#'truncate-string-to-width. Document what we should use instead.
ChangeLog addition:
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* configure.ac (TAB):
No longer check for wcwidth().
diff -r b2979b81a386 -r fddc26a4bf70 ChangeLog
--- a/ChangeLog Tue Apr 10 10:14:38 2018 +0100
+++ b/ChangeLog Tue Apr 10 13:54:31 2018 +0100
＠＠ -1,3 +1,8 ＠＠
+2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * configure.ac (TAB):
+ No longer check for wcwidth().
+
2017-11-23 Aidan Kehoe <kehoea(a)parhasard.net>
* configure.ac:
diff -r b2979b81a386 -r fddc26a4bf70 configure.ac
--- a/configure.ac Tue Apr 10 10:14:38 2018 +0100
+++ b/configure.ac Tue Apr 10 13:54:31 2018 +0100
＠＠ -4563,7 +4563,7 ＠＠
dnl Check for POSIX functions.
dnl ----------------------------------------------------------------
-AC_CHECK_FUNCS(cbrt closedir dup2 eaccess fmod fpathconf frexp fsync ftime ftruncate getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setsid sigblock sighold sigprocmask snprintf strerror strlwr strupr symlink tzset ulimit umask usleep vlimit vsnprintf waitpid wcscmp wcslen wcwidth)
+AC_CHECK_FUNCS(cbrt closedir dup2 eaccess fmod fpathconf frexp fsync ftime ftruncate getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setsid sigblock sighold sigprocmask snprintf strerror strlwr strupr symlink tzset ulimit umask usleep vlimit vsnprintf waitpid wcscmp wcslen)
dnl getaddrinfo() is borked under hpux11
if test "$ac_cv_func_getaddrinfo" != "no" ; then
diff -r b2979b81a386 -r fddc26a4bf70 src/ChangeLog
--- a/src/ChangeLog Tue Apr 10 10:14:38 2018 +0100
+++ b/src/ChangeLog Tue Apr 10 13:54:31 2018 +0100
＠＠ -1,3 +1,12 ＠＠
+2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * config.h.in:
+ No need for HAVE_WCWIDTH anymore.
+ * unicode.c (unicode_char_columns):
+ Don't ever use wcwidth() in this function, it's not
+ reliable, and this gives test failures with
+ #'truncate-string-to-width. Document what we should use instead.
+
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* regex.c (compile_char_class):
diff -r b2979b81a386 -r fddc26a4bf70 src/config.h.in
--- a/src/config.h.in Tue Apr 10 10:14:38 2018 +0100
+++ b/src/config.h.in Tue Apr 10 13:54:31 2018 +0100
＠＠ -428,7 +428,6 ＠＠
#undef HAVE_WAITPID
#undef HAVE_WCSCMP
#undef HAVE_WCSLEN
-#undef HAVE_WCWIDTH
/* Functions and structs checked for vdb. */
#undef HAVE_MPROTECT
diff -r b2979b81a386 -r fddc26a4bf70 src/unicode.c
--- a/src/unicode.c Tue Apr 10 10:14:38 2018 +0100
+++ b/src/unicode.c Tue Apr 10 13:54:31 2018 +0100
＠＠ -2661,13 +2661,10 ＠＠
int
unicode_char_columns (int code)
{
-#if defined (HAVE_WCWIDTH) && defined (__STDC_ISO_10646__)
- return wcwidth ((wchar_t) code);
-#else
- /* #### We need to do a much better job here. Although maybe wcwidth()
- is available everywhere we care. ＠＠#### Copy the source for wcwidth().
- Also check under Windows for an equivalent. */
- /* #### Use a range table for this! */
+ /* #### wcwidth() isn't reliable. E.g. Debian GLIBC 2.24-11+deb9u1 gives
+ -1 for ?\uD55c. And of course it varies by platform anyway. This code
+ should instead use a character or range table generated from
+ EastAsianWidth.txt. */
if (
/* Tibetan */
(code >= 0x0F00 && code <= 0x0FFF) ||
＠＠ -2690,7 +2687,6 ＠＠
(code >= 0x20000 && code <= 0x2FFFF))
return 2;
return 1;
-#endif /* defined (HAVE_WCWIDTH) && defined (__STDC_ISO_10646__) */
}
#endif /* MULE */
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments
[COMMIT] Don't use wcwidth() in #'char-width, it's not reliable.
6 years, 6 months
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1523364871 -3600
# Tue Apr 10 13:54:31 2018 +0100
# Node ID fddc26a4bf701ec3b4d7c9d855e4ab41788d32f5
# Parent b2979b81a38663cd670146fe85967107dbe9d1eb
Don't use wcwidth() in #'char-width, it's not reliable.
src/ChangeLog addition:
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* config.h.in:
No need for HAVE_WCWIDTH anymore.
* unicode.c (unicode_char_columns):
Don't ever use wcwidth() in this function, it's not
reliable, and this gives test failures with
#'truncate-string-to-width. Document what we should use instead.
ChangeLog addition:
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* configure.ac (TAB):
No longer check for wcwidth().
diff -r b2979b81a386 -r fddc26a4bf70 ChangeLog
--- a/ChangeLog Tue Apr 10 10:14:38 2018 +0100
+++ b/ChangeLog Tue Apr 10 13:54:31 2018 +0100
＠＠ -1,3 +1,8 ＠＠
+2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * configure.ac (TAB):
+ No longer check for wcwidth().
+
2017-11-23 Aidan Kehoe <kehoea(a)parhasard.net>
* configure.ac:
diff -r b2979b81a386 -r fddc26a4bf70 configure.ac
--- a/configure.ac Tue Apr 10 10:14:38 2018 +0100
+++ b/configure.ac Tue Apr 10 13:54:31 2018 +0100
＠＠ -4563,7 +4563,7 ＠＠
dnl Check for POSIX functions.
dnl ----------------------------------------------------------------
-AC_CHECK_FUNCS(cbrt closedir dup2 eaccess fmod fpathconf frexp fsync ftime ftruncate getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setsid sigblock sighold sigprocmask snprintf strerror strlwr strupr symlink tzset ulimit umask usleep vlimit vsnprintf waitpid wcscmp wcslen wcwidth)
+AC_CHECK_FUNCS(cbrt closedir dup2 eaccess fmod fpathconf frexp fsync ftime ftruncate getaddrinfo gethostname getnameinfo getpagesize getrlimit gettimeofday getcwd link logb lrand48 matherr mkdir mktime perror poll random readlink rename res_init rint rmdir select setitimer setpgid setsid sigblock sighold sigprocmask snprintf strerror strlwr strupr symlink tzset ulimit umask usleep vlimit vsnprintf waitpid wcscmp wcslen)
dnl getaddrinfo() is borked under hpux11
if test "$ac_cv_func_getaddrinfo" != "no" ; then
diff -r b2979b81a386 -r fddc26a4bf70 src/ChangeLog
--- a/src/ChangeLog Tue Apr 10 10:14:38 2018 +0100
+++ b/src/ChangeLog Tue Apr 10 13:54:31 2018 +0100
＠＠ -1,3 +1,12 ＠＠
+2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * config.h.in:
+ No need for HAVE_WCWIDTH anymore.
+ * unicode.c (unicode_char_columns):
+ Don't ever use wcwidth() in this function, it's not
+ reliable, and this gives test failures with
+ #'truncate-string-to-width. Document what we should use instead.
+
2018-04-10 Aidan Kehoe <kehoea(a)parhasard.net>
* regex.c (compile_char_class):
diff -r b2979b81a386 -r fddc26a4bf70 src/config.h.in
--- a/src/config.h.in Tue Apr 10 10:14:38 2018 +0100
+++ b/src/config.h.in Tue Apr 10 13:54:31 2018 +0100
＠＠ -428,7 +428,6 ＠＠
#undef HAVE_WAITPID
#undef HAVE_WCSCMP
#undef HAVE_WCSLEN
-#undef HAVE_WCWIDTH
/* Functions and structs checked for vdb. */
#undef HAVE_MPROTECT
diff -r b2979b81a386 -r fddc26a4bf70 src/unicode.c
--- a/src/unicode.c Tue Apr 10 10:14:38 2018 +0100
+++ b/src/unicode.c Tue Apr 10 13:54:31 2018 +0100
＠＠ -2661,13 +2661,10 ＠＠
int
unicode_char_columns (int code)
{
-#if defined (HAVE_WCWIDTH) && defined (__STDC_ISO_10646__)
- return wcwidth ((wchar_t) code);
-#else
- /* #### We need to do a much better job here. Although maybe wcwidth()
- is available everywhere we care. ＠＠#### Copy the source for wcwidth().
- Also check under Windows for an equivalent. */
- /* #### Use a range table for this! */
+ /* #### wcwidth() isn't reliable. E.g. Debian GLIBC 2.24-11+deb9u1 gives
+ -1 for ?\uD55c. And of course it varies by platform anyway. This code
+ should instead use a character or range table generated from
+ EastAsianWidth.txt. */
if (
/* Tibetan */
(code >= 0x0F00 && code <= 0x0FFF) ||
＠＠ -2690,7 +2687,6 ＠＠
(code >= 0x20000 && code <= 0x2FFFF))
return 2;
return 1;
-#endif /* defined (HAVE_WCWIDTH) && defined (__STDC_ISO_10646__) */
}
#endif /* MULE */
--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after forty pints of stout’
(C. Moore)
- 1 participants
- 0 comments