Merge from trunk.

75 files changed, 1022 insertions, 837 deletions

diff --git a/ChangeLog b/ChangeLog
index c2b61b24e66..9c839658429 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2012-10-11  Kenichi Handa  <handa@gnu.org>
+
+        * .bzrignore: Add several files under admin/charsets.
+
 2012-10-08  Daniel Colascione  <dancol@dancol.org>
 
         * configure.ac: Add --with-w32 as a window system option.  Limit
diff --git a/admin/ChangeLog b/admin/ChangeLog
index c10ec67147b..ca2ebbdfa06 100644
--- a/admin/ChangeLog
+++ b/admin/ChangeLog
@@ -1,3 +1,27 @@
+2012-10-11  Kenichi Handa  <handa@gnu.org>
+
+        * charsets/mapconv: Adjusted for the change of mapfiles/*.gz to
+        mapfiles/*.
+
+        * charsets/gb180302.awk: Handle 4-byte sequences in the input file.
+
+        * charsets/Makefile: Be sure to call mapconv script of the current
+        directory.  Adjusted for the change of mapfiles/*.gz to
+        mapfiles/*.
+        (SED_SCRIPT): New variable.
+        (jisx2131-filter): New target.
+        (JISX2131.map): Use jisx2131-filter to filter out characters added
+        for the 2004 year version.
+        (clear): Remove ${SED_SCRIPT} too.
+
+        * charsets/mapfiles/MULE-ethiopic.map,
+        charsets/mapfiles/MULE-ipa.map,
+        charsets/mapfiles/MULE-is13194.map,
+        charsets/mapfiles/MULE-lviscii.map,
+        charsets/mapfiles/MULE-sisheng.map,
+        charsets/mapfiles/MULE-tibetan.map,
+        charsets/mapfiles/MULE-uviscii.map: Fix typo.
+
 2012-10-09  Glenn Morris  <rgm@gnu.org>
 
         * admin.el (cusver-scan-cus-start): New function.
diff --git a/admin/charsets/Makefile b/admin/charsets/Makefile
index b16e7ccd748..91f541979da 100644
--- a/admin/charsets/Makefile
+++ b/admin/charsets/Makefile
@@ -77,6 +77,7 @@ MULE =	MULE-ethiopic.map MULE-ipa.map MULE-is13194.map \
         MULE-lviscii.map MULE-uviscii.map
 
 TRANS_TABLE = cp51932.el eucjp-ms.el
+SED_SCRIPT = jisx2131-filter
 
 all: ${CHARSETS} ${TRANS_TABLE}
 
@@ -86,11 +87,11 @@ AWK = gawk
 
 VSCII.map: ${GLIBC_CHARMAPS}/TCVN5712-1.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[0-9a-f].[  ]/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[0-9a-f].[  ]/' GLIBC-1 compact.awk > $@
 
 VSCII-2.map: ${GLIBC_CHARMAPS}/TCVN5712-1.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[2-7a-f].[  ]/' GLIBC-1 compact.awk \
+        @./mapconv $< '/^<.*[   ]\/x[2-7a-f].[  ]/' GLIBC-1 compact.awk \
           | sed 's/0x20-0x7F.*/0x00-0x7F 0x0000/' > $@
 
 ALTERNATIVNYJ.map: IBM866.map
@@ -110,45 +111,45 @@ ALTERNATIVNYJ.map: IBM866.map
              -e '/0xFA/ s/ .*/ 0x00B1/' \
              -e '/0xFB/ s/ .*/ 0x00F7/' < $< >> $@
 
-MIK.map: mapfiles/bulgarian-mik.txt.gz mapconv compact.awk
+MIK.map: mapfiles/bulgarian-mik.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '1,$$' CZYBORRA compact.awk > $@
+        @./mapconv $< '1,$$' CZYBORRA compact.awk > $@
 
-PTCP154.map: mapfiles/PTCP154.gz mapconv compact.awk
+PTCP154.map: mapfiles/PTCP154 mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^0x/' IANA compact.awk > $@
+        @./mapconv $< '/^0x/' IANA compact.awk > $@
 
-stdenc.map: mapfiles/stdenc.txt.gz mapconv compact.awk
+stdenc.map: mapfiles/stdenc.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^[0-9A-Fa-f]/' UNICODE compact.awk > $@
+        @./mapconv $< '/^[0-9A-Fa-f]/' UNICODE compact.awk > $@
 
-symbol.map: mapfiles/symbol.txt.gz mapconv compact.awk
+symbol.map: mapfiles/symbol.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^[0-9A-Fa-f]/' UNICODE compact.awk > $@
+        @./mapconv $< '/^[0-9A-Fa-f]/' UNICODE compact.awk > $@
 
-CP720.map: mapfiles/CP720.map.gz
+CP720.map: mapfiles/CP720.map
         # Generating $@...
-        @zcat $< > $@
+        @cp $< $@
 
-CP858.map: mapfiles/CP858.map.gz
+CP858.map: mapfiles/CP858.map
         # Generating $@...
-        @zcat $< > $@
+        @cp $< $@
 
 CP949-2BYTE.map: ${GLIBC_CHARMAPS}/CP949.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
 
 GB2312.map: ${GLIBC_CHARMAPS}/GB2312.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
 
 GBK.map: ${GLIBC_CHARMAPS}/GBK.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
 
 GB180302.map: ${GLIBC_CHARMAPS}/GB18030.gz mapconv gb180302.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x..\/x..[    ]/' GLIBC-2 gb180302.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x..\/x..[    ]/' GLIBC-2 gb180302.awk > $@
 
 GB180304.map: GB180302.map gb180304.awk
         # Generating $@...
@@ -156,35 +157,39 @@ GB180304.map: GB180302.map gb180304.awk
 
 JISX0201.map: ${GLIBC_CHARMAPS}/JIS_X0201.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[0-9]/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[0-9]/' GLIBC-1 compact.awk > $@
         @echo "# Generated by hand" >> $@
         @echo "0xA1-0xDF 0xFF61" >> $@
 
 JISX0208.map: ${GLIBC_CHARMAPS}/EUC-JP.gz mapconv
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2-7 \
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2-7 \
           | sed 's/0x2015/0x2014/' > $@
 
 JISX0212.map: ${GLIBC_CHARMAPS}/EUC-JP.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x8f/ s,/x8f,,' GLIBC-2-7 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x8f/ s,/x8f,,' GLIBC-2-7 compact.awk > $@
 
-JISX2131.map: ${GLIBC_CHARMAPS}/EUC-JISX0213.gz mapconv
+jisx2131-filter: mapfiles/JISX213A.map
+        @sed -n -e '/^#/d' -e 's,.*0x\([0-9A-Z]*\)$$,/0x0*\1$$/d,p' < $< > $@
+
+JISX2131.map: ${GLIBC_CHARMAPS}/EUC-JISX0213.gz mapconv jisx2131-filter
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2-7 \
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2-7 \
+          | sed -f jisx2131-filter \
           | sed -e 's/0x2015/0x2014/' -e 's/0x2299/0x29BF/' > $@
 
 JISX2132.map: ${GLIBC_CHARMAPS}/EUC-JISX0213.gz mapconv
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x8f/ s,/x8f,,' GLIBC-2-7 > $@
+        @./mapconv $< '/^<.*[   ]\/x8f/ s,/x8f,,' GLIBC-2-7 > $@
 
-JISX213A.map: mapfiles/JISX213A.map.gz
+JISX213A.map: mapfiles/JISX213A.map
         # Generating $@
-        @zcat $< > $@
+        @cp $<  $@
 
-CP932-2BYTE.map: mapfiles/CP932.TXT.gz mapconv cp932.awk
+CP932-2BYTE.map: mapfiles/CP932.TXT mapconv cp932.awk
         # Generating $@...
-        @mapconv $< '/^0x[89A-F][0-9A-F][0-9A-F]/' UNICODE2 cp932.awk > $@
+        @./mapconv $< '/^0x[89A-F][0-9A-F][0-9A-F]/' UNICODE2 cp932.awk > $@
 
 cp51932.el: CP932-2BYTE.map cp51932.awk
         @$(AWK) -f cp51932.awk < CP932-2BYTE.map > $@
@@ -192,17 +197,17 @@ cp51932.el: CP932-2BYTE.map cp51932.awk
 eucjp-ms.el: ${GLIBC_CHARMAPS}/EUC-JP-MS.gz eucjp-ms.awk
         @zcat $< | $(AWK) -f eucjp-ms.awk > $@
 
-JISC6226.map : mapfiles/Uni2JIS.gz mapconv kuten.awk
+JISC6226.map : mapfiles/Uni2JIS mapconv kuten.awk
         # Generating $@...
-        @mapconv $< '/^[^#].*0-/' YASUOKA kuten.awk > $@
+        @./mapconv $< '/^[^#].*0-/' YASUOKA kuten.awk > $@
 
 KSC5601.map: ${GLIBC_CHARMAPS}/EUC-KR.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
 
 BIG5.map: ${GLIBC_CHARMAPS}/BIG5.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2 > $@
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2 > $@
 
 BIG5-1.map: BIG5.map mapconv big5.awk
         # Generating $@...
@@ -216,52 +221,52 @@ BIG5-2.map: BIG5.map mapconv big5.awk
 
 BIG5-HKSCS.map: ${GLIBC_CHARMAPS}/BIG5-HKSCS.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[89a-f].\//' GLIBC-2 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[89a-f].\//' GLIBC-2 compact.awk > $@
 
 JOHAB.map: ${GLIBC_CHARMAPS}/JOHAB.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[89a-f]/' GLIBC-2 compact.awk > $@
 
 CNS-1.map: ${GLIBC_CHARMAPS}/EUC-TW.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x[a-f]/' GLIBC-2-7 compact.awk > $@
 
 # CNS-1.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
 #       # Generating $@...
-#       @mapconv $< '/^C1/' KANJI-DATABASE compact.awk > $@
+#       @./mapconv $< '/^C1/' KANJI-DATABASE compact.awk > $@
 
-CNS-2.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-2.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C2/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C2/' KANJI-DATABASE compact.awk > $@
 
-CNS-3.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-3.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C3/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C3/' KANJI-DATABASE compact.awk > $@
 
-CNS-4.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-4.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C4/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C4/' KANJI-DATABASE compact.awk > $@
 
-CNS-5.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-5.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C5/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C5/' KANJI-DATABASE compact.awk > $@
 
-CNS-6.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-6.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C6/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C6/' KANJI-DATABASE compact.awk > $@
 
-CNS-7.map: mapfiles/cns2ucsdkw.txt.gz mapconv compact.awk
+CNS-7.map: mapfiles/cns2ucsdkw.txt mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^C7/' KANJI-DATABASE compact.awk > $@
+        @./mapconv $< '/^C7/' KANJI-DATABASE compact.awk > $@
 
 CNS-F.map: ${GLIBC_CHARMAPS}/EUC-TW.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*\/x8e\/xaf/ s,/x8e/xaf,,' GLIBC-2-7 compact.awk > $@
+        @./mapconv $< '/^<.*\/x8e\/xaf/ s,/x8e/xaf,,' GLIBC-2-7 compact.awk > $@
 
 # General target to produce map files for mule charsets.
-MULE-%.map: mapfiles/MULE-%.map.gz
+MULE-%.map: mapfiles/MULE-%.map
         # Generating $@...
-        @zcat $< > $@
+        @cp $< $@
 
 # General target to produce map files for ISO-8859, GEORGIAN, and
 # EBCDIC charsets.  We can not use the original file name because of
@@ -269,21 +274,21 @@ MULE-%.map: mapfiles/MULE-%.map.gz
 
 8859-%.map: ${GLIBC_CHARMAPS}/ISO-8859-%.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x/' GLIBC-1 compact.awk > $@
 
 KA-%.map: ${GLIBC_CHARMAPS}/GEORGIAN-%.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x/' GLIBC-1 compact.awk > $@
 
 EBCDIC%.map: ${GLIBC_CHARMAPS}/EBCDIC-%.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x/' GLIBC-1 compact.awk > $@
 
 # General target to produce map files for single-byte charsets.
 
 %.map: ${GLIBC_CHARMAPS}/%.gz mapconv compact.awk
         # Generating $@...
-        @mapconv $< '/^<.*[     ]\/x/' GLIBC-1 compact.awk > $@
+        @./mapconv $< '/^<.*[   ]\/x/' GLIBC-1 compact.awk > $@
 
 install:
         @for f in ${CHARSETS}; do \
@@ -305,5 +310,5 @@ install:
 
 # Clear files that are automatically generated.
 clean:
-        rm -f ${CHARSETS} ${TRANS_TABLE}
+        rm -f ${CHARSETS} ${TRANS_TABLE} ${SED_SCRIPT}
 
diff --git a/admin/charsets/gb180302.awk b/admin/charsets/gb180302.awk
index 6cd9521ce90..40d92bf9be4 100644
--- a/admin/charsets/gb180302.awk
+++ b/admin/charsets/gb180302.awk
@@ -74,19 +74,30 @@ function index_to_gb(idx) {
 
 {
   gb = gb_to_index(decode_hex(substr($1, 3, 4)));
-  unicode = decode_hex(substr($2, 3, 4));
+  unicode = decode_hex(substr($2, 3));
   if ((gb == to_gb + 1) && (unicode == to_unicode + 1))
     {
       to_gb++;
       to_unicode++;
     }
-  else
+  else if (gb > to_gb) # ignore the case gb == to_gb that is a duplication
     {
       if (from_gb == to_gb)
-        printf "0x%04X 0x%04X\n", index_to_gb(from_gb), from_unicode;
+        {
+          if (from_unicode <= 65535)
+            printf "0x%04X 0x%04X\n", index_to_gb(from_gb), from_unicode;
+          else
+            printf "0x%04X 0x%08X\n", index_to_gb(from_gb), from_unicode;
+        }
       else if (from_gb < to_gb)
-        printf "0x%04X-0x%04X 0x%04X\n",
-          index_to_gb(from_gb), index_to_gb(to_gb), from_unicode;
+        {
+          if (from_unicode <= 65535)
+            printf "0x%04X-0x%04X 0x%04X\n",
+                index_to_gb(from_gb), index_to_gb(to_gb), from_unicode;
+          else
+            printf "0x%04X-0x%04X 0x%08X\n",
+                index_to_gb(from_gb), index_to_gb(to_gb), from_unicode;
+        }
       from_gb = to_gb = gb;
       from_unicode = to_unicode = unicode;
     }
diff --git a/admin/charsets/mapconv b/admin/charsets/mapconv
index 4f7a8b96f54..8433d222b8d 100755
--- a/admin/charsets/mapconv
+++ b/admin/charsets/mapconv
@@ -98,18 +98,17 @@ elif [ "$3" = "GLIBC-2-7" ] ; then
         | sed -e 's/xa/x2/g' -e 's/xb/x3/g' -e 's/xc/x4/g' \
               -e 's/xd/x5/g' -e 's/xe/x6/g' -e 's/xf/x7/g' \
               -e 's,<U\([^>]*\)>[       ]*/x\(..\)/x\(..\).*,0x\2\3 0x\1,' \
-        | tee temp \
         | sort | ${AWKPROG}
 elif [ "$3" = "CZYBORRA" ] ; then
     # Source format is:
     #   =XX     U+YYYY
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/=\(..\)[^U]*U+\([0-9A-F]*\).*/0x\1 0x\2/' \
         | sort | ${AWKPROG}
 elif [ "$3" = "IANA" ] ; then
     # Source format is:
     #   0xXX    0xYYYY
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/\(0x[0-9A-Fa-f]*\)[^0]*\(0x[0-9A-Fa-f]*\).*/\1 \2/' \
         | sort | ${AWKPROG}
 elif [ "$3" = "UNICODE" ] ; then
@@ -117,25 +116,25 @@ elif [ "$3" = "UNICODE" ] ; then
     #   YYYY    XX
     # We perform reverse sort to prefer the first one in the
     # duplicated mappings (e.g. 0x20->U+0020, 0x20->U+00A0).
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/\([0-9A-F]*\)[^0-9A-F]*\([0-9A-F]*\).*/0x\2 0x\1/' \
         | sort -r
 elif [ "$3" = "UNICODE2" ] ; then
     # Source format is:
     #   0xXXXX  0xYYYY  # ...
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/\([0-9A-Fx]*\)[^0]*\([0-9A-Fx]*\).*/\1 \2/' \
         | ${AWKPROG} | sort -n -k 4,4
 elif [ "$3" = "YASUOKA" ] ; then
     # Source format is:
     # YYYY      0-XXXX (XXXX is a Kuten code)
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/\([0-9A-F]*\)[^0]*0-\([0-9]*\).*/0x\2 0x\1/' \
         | sort | ${AWKPROG}
 elif [ "$3" = "KANJI-DATABASE" ] ; then
     # Source format is:
     # C?-XXXX U+YYYYY .....
-    zcat $1 | sed -n -e "$2 p" \
+    sed -n -e "$2 p" < $1 \
         | sed -e 's/...\(....\) U+\([0-9A-F]*\).*/0x\1 0x\2/' \
         | sort | ${AWKPROG}
 else
diff --git a/admin/charsets/mapfiles/MULE-ethiopic.map b/admin/charsets/mapfiles/MULE-ethiopic.map
index d2720bd10ba..30cf5736763 100644
--- a/admin/charsets/mapfiles/MULE-ethiopic.map
+++ b/admin/charsets/mapfiles/MULE-ethiopic.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x2121 0x1200
 0x2122 0x1201
 0x2123 0x1202
diff --git a/admin/charsets/mapfiles/MULE-ipa.map b/admin/charsets/mapfiles/MULE-ipa.map
index 35e5d50ecec..0a6c61d5a95 100644
--- a/admin/charsets/mapfiles/MULE-ipa.map
+++ b/admin/charsets/mapfiles/MULE-ipa.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x20 0x0069
 0x21 0x026A
 0x22 0x0065
diff --git a/admin/charsets/mapfiles/MULE-is13194.map b/admin/charsets/mapfiles/MULE-is13194.map
index 1fa9b21dcf8..390132cd375 100644
--- a/admin/charsets/mapfiles/MULE-is13194.map
+++ b/admin/charsets/mapfiles/MULE-is13194.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x21 0x0901
 0x22 0x0902
 0x23 0x0903
diff --git a/admin/charsets/mapfiles/MULE-lviscii.map b/admin/charsets/mapfiles/MULE-lviscii.map
index 3b6a38be616..e4d2eca90ac 100644
--- a/admin/charsets/mapfiles/MULE-lviscii.map
+++ b/admin/charsets/mapfiles/MULE-lviscii.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x21 0x1EAF
 0x22 0x1EB1
 0x23 0x1EB7
diff --git a/admin/charsets/mapfiles/MULE-sisheng.map b/admin/charsets/mapfiles/MULE-sisheng.map
index 405bb1ffa2c..144a3ff5134 100644
--- a/admin/charsets/mapfiles/MULE-sisheng.map
+++ b/admin/charsets/mapfiles/MULE-sisheng.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x21 0x0101
 0x22 0x00E1
 0x23 0x01CE
diff --git a/admin/charsets/mapfiles/MULE-tibetan.map b/admin/charsets/mapfiles/MULE-tibetan.map
index 0d6ff3a0a39..b885585c094 100644
--- a/admin/charsets/mapfiles/MULE-tibetan.map
+++ b/admin/charsets/mapfiles/MULE-tibetan.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x2130 0x0F00
 0x2131 0x0F01
 0x2132 0x0F02
diff --git a/admin/charsets/mapfiles/MULE-uviscii.map b/admin/charsets/mapfiles/MULE-uviscii.map
index 65e5d2968e5..dc19583bdfe 100644
--- a/admin/charsets/mapfiles/MULE-uviscii.map
+++ b/admin/charsets/mapfiles/MULE-uviscii.map
@@ -1,4 +1,4 @@
-# Generated by running amdin/charsets/mule-charsets.el in Emacs 22.3.
+# Generated by running admin/charsets/mule-charsets.el in Emacs 22.3.
 0x21 0x1EAE
 0x22 0x1EB0
 0x23 0x1EB6
diff --git a/doc/emacs/ChangeLog b/doc/emacs/ChangeLog
index 87ff64b576d..3aad65f7bed 100644
--- a/doc/emacs/ChangeLog
+++ b/doc/emacs/ChangeLog
@@ -1,3 +1,7 @@
+2012-10-10  Dani Moncayo  <dmoncayo@gmail.com>
+
+        * basic.texi (Arguments): Fix typos.
+
 2012-10-08  Glenn Morris  <rgm@gnu.org>
 
         * cal-xtra.texi (Calendar Customizing): Mention calendar-month-header.
@@ -425,7 +429,7 @@
         * misc.texi (emacsclient Options): Add cross-reference to "Windows
         Startup".  (Bug#11091)
 
-2012-04-02  Dani Moncayo  <dmoncayo@gmail.com>  (tiny change)
+2012-04-02  Dani Moncayo  <dmoncayo@gmail.com>
 
         * custom.texi (Changing a Variable): Fix example.
 
@@ -458,7 +462,7 @@
         * mule.texi (International Chars):
         etc/HELLO is for character demonstration.
 
-2012-03-15  Dani Moncayo  <dmoncayo@gmail.com>  (tiny change)
+2012-03-15  Dani Moncayo  <dmoncayo@gmail.com>
 
         * dired.texi (Shell Commands in Dired): Fix typo.
 
@@ -485,7 +489,7 @@
         * macos.texi (Mac / GNUstep Customization): Remove text about
         ns-find-file and ns-drag-file (Bug#5855, Bug#10050).
 
-2012-02-25  Dani Moncayo  <dmoncayo@gmail.com>  (tiny change)
+2012-02-25  Dani Moncayo  <dmoncayo@gmail.com>
 
         * buffers.texi (Select Buffer): Mention that saving in a new file
         name can switch to a different major mode.
diff --git a/doc/emacs/basic.texi b/doc/emacs/basic.texi
index 42bd2a4fde2..07060db5af2 100644
--- a/doc/emacs/basic.texi
+++ b/doc/emacs/basic.texi
@@ -757,7 +757,8 @@ the character @samp{1}.
 value.  For example, the command @kbd{M-q} (@code{fill-paragraph})
 fills text; with an argument, it justifies the text as well.
 (@xref{Filling}, for more information on @kbd{M-q}.)  For these
-commands, it is enough to the argument with a single @kbd{C-u}.
+commands, it is enough to specify the argument with a single
+@kbd{C-u}.
 
   Some commands use the value of the argument as a repeat count, but
 do something special when there is no argument.  For example, the
@@ -776,10 +777,10 @@ described when they come up; they exist to make an individual command
 more convenient, and they are documented in that command's
 documentation string.
 
-  We use the term ``prefix argument'' as well as ``numeric argument'',
-to emphasize that you type these argument before the command, and to
-distinguish them from minibuffer arguments that come after the
-command.
+  We use the term @dfn{prefix argument} to emphasize that you type
+such arguments before the command, and to distinguish them from
+minibuffer arguments (@pxref{Minibuffer}), which are entered after
+invoking the command.
 
 @node Repeating
 @section Repeating a Command
diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 7609efb8ac9..974a0d67192 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1978,7 +1978,7 @@
         * numbers.texi (Integer Basics): Add indexing for
         most-positive-fixnum and most-negative-fixnum.  (Bug#9525)
 
-2011-09-14  Dani Moncayo  <dmoncayo@gmail.com>  (tiny change)
+2011-09-14  Dani Moncayo  <dmoncayo@gmail.com>
 
         * lists.texi (Sets And Lists): Fix typo.  (Bug#9393)
 
@@ -1987,7 +1987,7 @@
         * processes.texi (Network Servers): Clarify what the process
         buffer is used for (bug#9233).
 
-2011-08-30  Dani Moncayo  <dmoncayo@gmail.com>  (tiny change)
+2011-08-30  Dani Moncayo  <dmoncayo@gmail.com>
 
         * lists.texi (Building Lists): Fix typo.
 
diff --git a/etc/ChangeLog b/etc/ChangeLog
index 001bfe271af..2bfae3696c5 100644
--- a/etc/ChangeLog
+++ b/etc/ChangeLog
@@ -1,3 +1,12 @@
+2012-10-11  Kenichi Handa  <handa@gnu.org>
+
+        * charsets/CNS-2.map, charsets/CNS-3.map, charsets/CNS-4.map,
+        charsets/CNS-5.map, charsets/CNS-6.map, charsets/CNS-7.map,
+        charsets/CP932-2BYTE.map, charsets/GB180302.map,
+        charsets/GB180304.map, charsets/JISC6226.map,
+        charsets/JISX2131.map, charsets/MIK.map, charsets/PTCP154.map,
+        charsets/stdenc.map, charsets/symbol.map: Re-generated.
+
 2012-10-07  Jan Djärv  <jan.h.d@swipnet.se>
 
         * NEWS (NextStep/OSX port changes): OSX 10.4 or newer is required.
diff --git a/etc/charsets/CNS-2.map b/etc/charsets/CNS-2.map
index 7fdd4ae0498..1285859a36d 100644
--- a/etc/charsets/CNS-2.map
+++ b/etc/charsets/CNS-2.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x4E42
 0x2122 0x4E5C
diff --git a/etc/charsets/CNS-3.map b/etc/charsets/CNS-3.map
index f1542f9da91..d7306a9d81f 100644
--- a/etc/charsets/CNS-3.map
+++ b/etc/charsets/CNS-3.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x4E28
 0x2122 0x4E36
diff --git a/etc/charsets/CNS-4.map b/etc/charsets/CNS-4.map
index 8f9f2333c95..ba4f0e7a1fb 100644
--- a/etc/charsets/CNS-4.map
+++ b/etc/charsets/CNS-4.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x20086
 0x2122-0x2123 0x4E40
diff --git a/etc/charsets/CNS-5.map b/etc/charsets/CNS-5.map
index c893f164961..bf6bb9d4653 100644
--- a/etc/charsets/CNS-5.map
+++ b/etc/charsets/CNS-5.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x200D1
 0x2122 0x200CB
diff --git a/etc/charsets/CNS-6.map b/etc/charsets/CNS-6.map
index 90c048035c0..348416c1c1e 100644
--- a/etc/charsets/CNS-6.map
+++ b/etc/charsets/CNS-6.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x2F802
 0x2122 0x20062
diff --git a/etc/charsets/CNS-7.map b/etc/charsets/CNS-7.map
index 96c1ad0efed..5a621737444 100644
--- a/etc/charsets/CNS-7.map
+++ b/etc/charsets/CNS-7.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/cns2ucsdkw.txt which is a copy of
 # http://kanji-database.cvs.sourceforge.net/viewvc/*checkout*/kanji-database/kanji-database/data/cns2ucsdkw.txt?revision=1.4
 0x2121 0x20055
 0x2122 0x20182
diff --git a/etc/charsets/CP932-2BYTE.map b/etc/charsets/CP932-2BYTE.map
index 045fdc98659..d31770892a6 100644
--- a/etc/charsets/CP932-2BYTE.map
+++ b/etc/charsets/CP932-2BYTE.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/CP932.TXT.gz which is a copy of
+# Generated from admin/charsets/mapfiles/CP932.TXT which is a copy of
 # http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT
 0x8140 0x3000 # 0 2121
 0x8141 0x3001 # 0 2122
diff --git a/etc/charsets/GB180302.map b/etc/charsets/GB180302.map
index ee7e0ecd42e..4fe8e530a2b 100644
--- a/etc/charsets/GB180302.map
+++ b/etc/charsets/GB180302.map
@@ -2048,20 +2048,17 @@
 0xA6B9-0xA6C0 0xE785
 0xA6C1-0xA6D1 0x03B1
 0xA6D2-0xA6D8 0x03C3
-0xA6D9 0xFE10
-0xA6DA 0xFE12
-0xA6DB 0xFE11
-0xA6DC-0xA6DF 0xFE13
+0xA6D9-0xA6DF 0xE78D
 0xA6E0-0xA6E1 0xFE35
 0xA6E2-0xA6E3 0xFE39
 0xA6E4-0xA6E5 0xFE3F
 0xA6E6-0xA6E7 0xFE3D
 0xA6E8-0xA6EB 0xFE41
-0xA6EC-0xA6ED 0xFE17
+0xA6EC-0xA6ED 0xE794
 0xA6EE-0xA6EF 0xFE3B
 0xA6F0-0xA6F1 0xFE37
 0xA6F2 0xFE31
-0xA6F3 0xFE19
+0xA6F3 0xE796
 0xA6F4-0xA6F5 0xFE33
 0xA6F6-0xA6FE 0xE797
 0xA740-0xA77E 0xE706
@@ -10396,7 +10393,7 @@
 0xFE56 0x3447
 0xFE57 0x2E88
 0xFE58 0x2E8B
-0xFE59 0x9FB4
+0xFE59 0xE81E
 0xFE5A 0x359E
 0xFE5B 0x361A
 0xFE5C 0x360E
@@ -10404,18 +10401,18 @@
 0xFE5E 0x2E97
 0xFE5F 0x396E
 0xFE60 0x3918
-0xFE61 0x9FB5
+0xFE61 0xE826
 0xFE62 0x39CF
 0xFE63 0x39DF
 0xFE64 0x3A73
 0xFE65 0x39D0
-0xFE66-0xFE67 0x9FB6
+0xFE66-0xFE67 0xE82B
 0xFE68 0x3B4E
 0xFE69 0x3C6E
 0xFE6A 0x3CE0
 0xFE6B 0x2EA7
 0xFE6C 0x000215D7
-0xFE6D 0x9FB8
+0xFE6D 0xE832
 0xFE6E 0x2EAA
 0xFE6F 0x4056
 0xFE70 0x415F
@@ -10431,7 +10428,7 @@
 0xFE7B 0x44D6
 0xFE7C 0x4661
 0xFE7D 0x464C
-0xFE7E 0x9FB9
+0xFE7E 0xE843
 0xFE80 0x4723
 0xFE81 0x4729
 0xFE82 0x477C
@@ -10446,7 +10443,7 @@
 0xFE8D 0x499B
 0xFE8E 0x49B7
 0xFE8F 0x49B6
-0xFE90 0x9FBA
+0xFE90 0xE854
 0xFE91 0x000241FE
 0xFE92 0x4CA3
 0xFE93-0xFE95 0x4C9F
@@ -10454,5 +10451,5 @@
 0xFE97 0x4CA2
 0xFE98-0xFE9E 0x4D13
 0xFE9F 0x4DAE
-0xFEA0 0x9FBB
+0xFEA0 0xE864
 0xFEA1-0xFEFE 0xE468
diff --git a/etc/charsets/GB180304.map b/etc/charsets/GB180304.map
index 31352e266c8..042c7514fab 100644
--- a/etc/charsets/GB180304.map
+++ b/etc/charsets/GB180304.map
@@ -41,171 +41,166 @@
 0x8130D135-0x8130D238   0x0402
 0x8130D239              0x0450
 0x8130D330-0x8135F436   0x0452
-0x8135F438-0x8136A531   0x1E40
-0x8136A532-0x8136A533   0x2011
-0x8136A534              0x2017
-0x8136A535-0x8136A536   0x201A
-0x8136A537-0x8136A633   0x201E
-0x8136A634-0x8136A732   0x2027
-0x8136A733              0x2031
-0x8136A734              0x2034
-0x8136A735-0x8136A739   0x2036
-0x8136A830-0x8136B331   0x203C
-0x8136B332-0x8136BB37   0x20AD
-0x8136BB38              0x2104
-0x8136BB39-0x8136BC31   0x2106
-0x8136BC32-0x8136BD33   0x210A
-0x8136BD34-0x8136BE33   0x2117
-0x8136BE34-0x8136C435   0x2122
-0x8136C436-0x8136C439   0x216C
-0x8136C530-0x8136C731   0x217A
-0x8136C732-0x8136C733   0x2194
-0x8136C734-0x8136D233   0x219A
-0x8136D234-0x8136D239   0x2209
-0x8136D330              0x2210
-0x8136D331-0x8136D333   0x2212
-0x8136D334-0x8136D337   0x2216
-0x8136D338-0x8136D339   0x221B
-0x8136D430-0x8136D431   0x2221
-0x8136D432              0x2224
-0x8136D433              0x2226
-0x8136D434-0x8136D435   0x222C
-0x8136D436-0x8136D530   0x222F
-0x8136D531-0x8136D535   0x2238
-0x8136D536-0x8136D635   0x223E
-0x8136D636-0x8136D638   0x2249
-0x8136D639-0x8136D733   0x224D
-0x8136D734-0x8136D836   0x2253
-0x8136D837-0x8136D838   0x2262
-0x8136D839-0x8136D934   0x2268
-0x8136D935-0x8136DD31   0x2270
-0x8136DD32-0x8136DD34   0x2296
-0x8136DD35-0x8136DE35   0x229A
-0x8136DE36-0x8136E130   0x22A6
-0x8136E131-0x8136E932   0x22C0
-0x8136E933-0x81378C35   0x2313
-0x81378C36-0x81378D35   0x246A
-0x81378D36-0x81379735   0x249C
-0x81379736-0x81379739   0x254C
-0x81379830-0x81379932   0x2574
-0x81379933-0x81379935   0x2590
-0x81379936-0x81379A35   0x2596
-0x81379A36-0x81379C31   0x25A2
-0x81379C32-0x81379C39   0x25B4
-0x81379D30-0x81379D37   0x25BE
-0x81379D38-0x81379E30   0x25C8
-0x81379E31-0x81379E32   0x25CC
-0x81379E33-0x8137A030   0x25D0
-0x8137A031-0x8137A331   0x25E6
-0x8137A332-0x8137A333   0x2607
-0x8137A334-0x8137A837   0x260A
-0x8137A838              0x2641
-0x8137A839-0x8138FD38   0x2643
-0x8138FD39-0x8138FE30   0x2E82
-0x8138FE31-0x8138FE33   0x2E85
-0x8138FE34-0x8138FE35   0x2E89
-0x8138FE36-0x81398135   0x2E8D
-0x81398136-0x81398330   0x2E98
-0x81398331-0x81398332   0x2EA8
-0x81398333-0x81398335   0x2EAB
-0x81398336-0x81398339   0x2EAF
-0x81398430-0x81398431   0x2EB4
-0x81398432-0x81398434   0x2EB8
-0x81398435-0x81398538   0x2EBC
-0x81398539-0x8139A331   0x2ECB
-0x8139A332-0x8139A335   0x2FFC
-0x8139A336              0x3004
-0x8139A337-0x8139A431   0x3018
-0x8139A432-0x8139A433   0x301F
-0x8139A434-0x8139A633   0x302A
-0x8139A634-0x8139A635   0x303F
-0x8139A636-0x8139A732   0x3094
-0x8139A733-0x8139A734   0x309F
-0x8139A735-0x8139A739   0x30F7
-0x8139A830-0x8139A835   0x30FF
-0x8139A836-0x8139C131   0x312A
-0x8139C132-0x8139C138   0x322A
-0x8139C139-0x8139CD31   0x3232
-0x8139CD32-0x8139E435   0x32A4
-0x8139E436-0x8139E537   0x3390
-0x8139E538-0x8139E539   0x339F
-0x8139E630-0x8139E933   0x33A2
-0x8139E934-0x8139EA32   0x33C5
-0x8139EA33-0x8139EA34   0x33CF
-0x8139EA35-0x8139EA36   0x33D3
-0x8139EA37-0x8139F539   0x33D6
-0x8139F630-0x8139FA32   0x3448
-0x8139FA33-0x82309A30   0x3474
-0x82309A31-0x8230A531   0x359F
-0x8230A532-0x8230A632   0x360F
-0x8230A633-0x8230F237   0x361B
-0x8230F238-0x8230FB32   0x3919
-0x8230FB33-0x82318638   0x396F
-0x82318639-0x82318832   0x39D1
-0x82318833-0x82319639   0x39E0
-0x82319730-0x8231AC37   0x3A74
-0x8231AC38-0x8231C934   0x3B4F
-0x8231C935-0x8231D437   0x3C6F
-0x8231D438-0x8232AF32   0x3CE1
-0x8232AF33-0x8232C936   0x4057
-0x8232C937-0x8232F837   0x4160
-0x8232F838-0x82338633   0x4338
-0x82338634-0x82338637   0x43AD
-0x82338638-0x82338B30   0x43B2
-0x82338B31-0x8233A338   0x43DE
-0x8233A339-0x8233C931   0x44D7
-0x8233C932-0x8233CB31   0x464D
-0x8233CB32-0x8233DE34   0x4662
-0x8233DE35-0x8233DE39   0x4724
-0x8233DF30-0x8233E731   0x472A
-0x8233E732-0x8233E837   0x477D
-0x8233E838-0x82349638   0x478E
-0x82349639-0x82349B38   0x4948
-0x82349B39-0x82349C30   0x497B
-0x82349C31-0x82349C34   0x497E
-0x82349C35              0x4984
-0x82349C36-0x82349E35   0x4987
-0x82349E36-0x82349E38   0x499C
-0x82349E39-0x8234A130   0x49A0
-0x8234A131-0x8234E733   0x49B8
-0x8234E734-0x8234EB32   0x4C78
-0x8234EB33-0x8234F633   0x4CA4
-0x8234F634-0x82358731   0x4D1A
-0x82358732-0x82358F32   0x4DAF
-0x82358F33-0x82359036   0x9FA6
-0x82359135-0x8336C738   0x9FBC
-0x8336C739              0xE76C
-0x8135F437              0xE7C7
-0x8336C830              0xE7C8
+0x8135F437-0x8136A530   0x1E40
+0x8136A531-0x8136A532   0x2011
+0x8136A533              0x2017
+0x8136A534-0x8136A535   0x201A
+0x8136A536-0x8136A632   0x201E
+0x8136A633-0x8136A731   0x2027
+0x8136A732              0x2031
+0x8136A733              0x2034
+0x8136A734-0x8136A738   0x2036
+0x8136A739-0x8136B330   0x203C
+0x8136B331-0x8136BB36   0x20AD
+0x8136BB37              0x2104
+0x8136BB38-0x8136BC30   0x2106
+0x8136BC31-0x8136BD32   0x210A
+0x8136BD33-0x8136BE32   0x2117
+0x8136BE33-0x8136C434   0x2122
+0x8136C435-0x8136C438   0x216C
+0x8136C439-0x8136C730   0x217A
+0x8136C731-0x8136C732   0x2194
+0x8136C733-0x8136D232   0x219A
+0x8136D233-0x8136D238   0x2209
+0x8136D239              0x2210
+0x8136D330-0x8136D332   0x2212
+0x8136D333-0x8136D336   0x2216
+0x8136D337-0x8136D338   0x221B
+0x8136D339-0x8136D430   0x2221
+0x8136D431              0x2224
+0x8136D432              0x2226
+0x8136D433-0x8136D434   0x222C
+0x8136D435-0x8136D439   0x222F
+0x8136D530-0x8136D534   0x2238
+0x8136D535-0x8136D634   0x223E
+0x8136D635-0x8136D637   0x2249
+0x8136D638-0x8136D732   0x224D
+0x8136D733-0x8136D835   0x2253
+0x8136D836-0x8136D837   0x2262
+0x8136D838-0x8136D933   0x2268
+0x8136D934-0x8136DD30   0x2270
+0x8136DD31-0x8136DD33   0x2296
+0x8136DD34-0x8136DE34   0x229A
+0x8136DE35-0x8136E039   0x22A6
+0x8136E130-0x8136E931   0x22C0
+0x8136E932-0x81378C34   0x2313
+0x81378C35-0x81378D34   0x246A
+0x81378D35-0x81379734   0x249C
+0x81379735-0x81379738   0x254C
+0x81379739-0x81379931   0x2574
+0x81379932-0x81379934   0x2590
+0x81379935-0x81379A34   0x2596
+0x81379A35-0x81379C30   0x25A2
+0x81379C31-0x81379C38   0x25B4
+0x81379C39-0x81379D36   0x25BE
+0x81379D37-0x81379D39   0x25C8
+0x81379E30-0x81379E31   0x25CC
+0x81379E32-0x81379F39   0x25D0
+0x8137A030-0x8137A330   0x25E6
+0x8137A331-0x8137A332   0x2607
+0x8137A333-0x8137A836   0x260A
+0x8137A837              0x2641
+0x8137A838-0x8138FD37   0x2643
+0x8138FD38-0x8138FD39   0x2E82
+0x8138FE30-0x8138FE32   0x2E85
+0x8138FE33-0x8138FE34   0x2E89
+0x8138FE35-0x81398134   0x2E8D
+0x81398135-0x81398239   0x2E98
+0x81398330-0x81398331   0x2EA8
+0x81398332-0x81398334   0x2EAB
+0x81398335-0x81398338   0x2EAF
+0x81398339-0x81398430   0x2EB4
+0x81398431-0x81398433   0x2EB8
+0x81398434-0x81398537   0x2EBC
+0x81398538-0x8139A330   0x2ECB
+0x8139A331-0x8139A334   0x2FFC
+0x8139A335              0x3004
+0x8139A336-0x8139A430   0x3018
+0x8139A431-0x8139A432   0x301F
+0x8139A433-0x8139A632   0x302A
+0x8139A633-0x8139A634   0x303F
+0x8139A635-0x8139A731   0x3094
+0x8139A732-0x8139A733   0x309F
+0x8139A734-0x8139A738   0x30F7
+0x8139A739-0x8139A834   0x30FF
+0x8139A835-0x8139C130   0x312A
+0x8139C131-0x8139C137   0x322A
+0x8139C138-0x8139CD30   0x3232
+0x8139CD31-0x8139E434   0x32A4
+0x8139E435-0x8139E536   0x3390
+0x8139E537-0x8139E538   0x339F
+0x8139E539-0x8139E932   0x33A2
+0x8139E933-0x8139EA31   0x33C5
+0x8139EA32-0x8139EA33   0x33CF
+0x8139EA34-0x8139EA35   0x33D3
+0x8139EA36-0x8139F538   0x33D6
+0x8139F539-0x8139FA31   0x3448
+0x8139FA32-0x82309939   0x3474
+0x82309A30-0x8230A530   0x359F
+0x8230A531-0x8230A631   0x360F
+0x8230A632-0x8230F236   0x361B
+0x8230F237-0x8230FB31   0x3919
+0x8230FB32-0x82318637   0x396F
+0x82318638-0x82318831   0x39D1
+0x82318832-0x82319638   0x39E0
+0x82319639-0x8231AC36   0x3A74
+0x8231AC37-0x8231C933   0x3B4F
+0x8231C934-0x8231D436   0x3C6F
+0x8231D437-0x8232AF31   0x3CE1
+0x8232AF32-0x8232C935   0x4057
+0x8232C936-0x8232F836   0x4160
+0x8232F837-0x82338632   0x4338
+0x82338633-0x82338636   0x43AD
+0x82338637-0x82338A39   0x43B2
+0x82338B30-0x8233A337   0x43DE
+0x8233A338-0x8233C930   0x44D7
+0x8233C931-0x8233CB30   0x464D
+0x8233CB31-0x8233DE33   0x4662
+0x8233DE34-0x8233DE38   0x4724
+0x8233DE39-0x8233E730   0x472A
+0x8233E731-0x8233E836   0x477D
+0x8233E837-0x82349637   0x478E
+0x82349638-0x82349B37   0x4948
+0x82349B38-0x82349B39   0x497B
+0x82349C30-0x82349C33   0x497E
+0x82349C34              0x4984
+0x82349C35-0x82349E34   0x4987
+0x82349E35-0x82349E37   0x499C
+0x82349E38-0x8234A039   0x49A0
+0x8234A130-0x8234E732   0x49B8
+0x8234E733-0x8234EB31   0x4C78
+0x8234EB32-0x8234F632   0x4CA4
+0x8234F633-0x82358730   0x4D1A
+0x82358731-0x82358F31   0x4DAF
+0x82358F32-0x8336C737   0x9FA6
+0x8336C738              0xE76C
+0x8336C739-0x8336C830   0xE7C7
 0x8336C831-0x8336C933   0xE7E7
-0x8336C934              0xE815
-0x8336C935-0x8336C939   0xE819
-0x8336CA30-0x8336CA36   0xE81F
-0x8336CA37-0x8336CB30   0xE827
-0x8336CB31-0x8336CB34   0xE82D
-0x8336CB35-0x8336CC32   0xE833
-0x8336CC33-0x8336CC39   0xE83C
-0x8336CD30-0x8336CE35   0xE844
-0x8336CE36-0x8336CF39   0xE856
-0x8336D030-0x84308534   0xE865
-0x84308535-0x84308D30   0xF92D
-0x84308D31-0x84308F37   0xF97A
-0x84308F38-0x84309738   0xF996
-0x84309739-0x84309837   0xF9E8
-0x84309838-0x84309B33   0xF9F2
-0x84309B34              0xFA10
-0x84309B35              0xFA12
-0x84309B36-0x84309B38   0xFA15
-0x84309B39-0x84309C34   0xFA19
-0x84309C35              0xFA22
-0x84309C36-0x84309C37   0xFA25
-0x84309C38-0x84318235   0xFA2A
-0x84318336-0x84318537   0xFE1A
-0x84318538              0xFE32
-0x84318539-0x84318632   0xFE45
-0x84318633              0xFE53
-0x84318634              0xFE58
-0x84318635              0xFE67
-0x84318636-0x84319534   0xFE6C
-0x84319535-0x8431A233   0xFF5F
-0x8431A234-0x8431A439   0xFFE6
+0x8336C934-0x8336CA32   0xE815
+0x8336CA33-0x8336CA39   0xE81F
+0x8336CB30-0x8336CB33   0xE827
+0x8336CB34-0x8336CB38   0xE82D
+0x8336CB39-0x8336CD34   0xE833
+0x8336CD35-0x8336CF30   0xE844
+0x8336CF31-0x8336D035   0xE855
+0x8336D036-0x84308630   0xE865
+0x84308631-0x84308D36   0xF92D
+0x84308D37-0x84309033   0xF97A
+0x84309034-0x84309834   0xF996
+0x84309835-0x84309933   0xF9E8
+0x84309934-0x84309B39   0xF9F2
+0x84309C30              0xFA10
+0x84309C31              0xFA12
+0x84309C32-0x84309C34   0xFA15
+0x84309C35-0x84309D30   0xFA19
+0x84309D31              0xFA22
+0x84309D32-0x84309D33   0xFA25
+0x84309D34-0x84318633   0xFA2A
+0x84318634              0xFE32
+0x84318635-0x84318638   0xFE45
+0x84318639              0xFE53
+0x84318730              0xFE58
+0x84318731              0xFE67
+0x84318732-0x84319630   0xFE6C
+0x84319631-0x8431A239   0xFF5F
+0x8431A330-0x8431A535   0xFFE6
diff --git a/etc/charsets/JISC6226.map b/etc/charsets/JISC6226.map
index 97d24651628..cba6df50b75 100644
--- a/etc/charsets/JISC6226.map
+++ b/etc/charsets/JISC6226.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/Uni2JIS.gz which is a copy of
+# Generated from admin/charsets/mapfiles/Uni2JIS which is a copy of
 # http://kanji.zinbun.kyoto-u.ac.jp/~yasuoka/ftp/CJKtable/Uni2JIS.Z
 0x2121 0x3000
 0x2122 0x3001
diff --git a/etc/charsets/JISX2131.map b/etc/charsets/JISX2131.map
index 5d62e99650b..5219a0ef1ef 100644
--- a/etc/charsets/JISX2131.map
+++ b/etc/charsets/JISX2131.map
@@ -1157,7 +1157,6 @@
 0x2d79 0x22BF
 0x2d7d 0x2756
 0x2d7e 0x261E
-0x2e21 0x4FF1
 0x2e22 0x0002000B
 0x2e23 0x3402
 0x2e24 0x4E28
@@ -1344,7 +1343,6 @@
 0x2f7b 0x000218BD
 0x2f7c 0x5B19
 0x2f7d 0x5B25
-0x2f7e 0x525D
 0x3021 0x4E9C
 0x3022 0x5516
 0x3023 0x5A03
@@ -4310,7 +4308,6 @@
 0x4f51 0x6E7E
 0x4f52 0x7897
 0x4f53 0x8155
-0x4f54 0x00020B9F
 0x4f55 0x5B41
 0x4f56 0x5B56
 0x4f57 0x5B7D
@@ -4352,7 +4349,6 @@
 0x4f7b 0x5DA7
 0x4f7c 0x5DB8
 0x4f7d 0x5DCB
-0x4f7e 0x541E
 0x5021 0x5F0C
 0x5022 0x4E10
 0x5023 0x4E15
@@ -7743,7 +7739,6 @@
 0x7424 0x7464
 0x7425 0x51DC
 0x7426 0x7199
-0x7427 0x5653
 0x7428 0x5DE2
 0x7429 0x5E14
 0x742a 0x5E18
@@ -8766,8 +8761,3 @@
 0x7e77 0x9F94
 0x7e78 0x9F97
 0x7e79 0x9FA2
-0x7e7a 0x59F8
-0x7e7b 0x5C5B
-0x7e7c 0x5E77
-0x7e7d 0x7626
-0x7e7e 0x7E6B
diff --git a/etc/charsets/MIK.map b/etc/charsets/MIK.map
index 5a1176f9f50..3bf3d0eb304 100644
--- a/etc/charsets/MIK.map
+++ b/etc/charsets/MIK.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/bulgarian-mik.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/bulgarian-mik.txt which is a copy of
 # http://czyborra.com/charsets/bulgarian-mik.txt.gz
 0x20-0x7E 0x0020
 0x80-0xBF 0x0410
diff --git a/etc/charsets/PTCP154.map b/etc/charsets/PTCP154.map
index 72c6b3484d4..c4aa33ac238 100644
--- a/etc/charsets/PTCP154.map
+++ b/etc/charsets/PTCP154.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/PTCP154.gz which is a copy of
+# Generated from admin/charsets/mapfiles/PTCP154 which is a copy of
 # http://www.iana.org/assignments/charset-reg/PTCP154
 0x00-0x7F 0x0000
 0x80 0x0496
diff --git a/etc/charsets/stdenc.map b/etc/charsets/stdenc.map
index ab23002b155..08985141ed2 100644
--- a/etc/charsets/stdenc.map
+++ b/etc/charsets/stdenc.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/stdenc.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/stdenc.txt which is a copy of
 # http://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/stdenc.txt
 0xFB 0x00DF
 0xFA 0x0153
diff --git a/etc/charsets/symbol.map b/etc/charsets/symbol.map
index 95dd2b65eea..8404bd407ba 100644
--- a/etc/charsets/symbol.map
+++ b/etc/charsets/symbol.map
@@ -1,4 +1,4 @@
-# Generated from admin/charsets/mapfiles/symbol.txt.gz which is a copy of
+# Generated from admin/charsets/mapfiles/symbol.txt which is a copy of
 # http://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/symbol.txt
 0xFE 0xF8FE
 0xFD 0xF8FD
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index ef9e06b7d58..7a73f761fa8 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,39 @@
+2012-10-12  Glenn Morris  <rgm@gnu.org>
+
+        * mail/rmailsum.el (rmail-header-summary):
+        Fix 2010-11-26 test for multiline Subject: field.  (Bug#12625)
+
+2012-10-12  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el (python-mode-map): Replace
+        subtitute-key-definition with proper command remapping.
+        (python-nav--up-list): Fix behavior for blocks on the same level.
+
+2012-10-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * help-fns.el (describe-function-1): Handle autoloads w/o docstrings.
+
+        * emacs-lisp/bytecomp.el (byte-compile-eval): Adjust to long-ago
+        changes to the format of load-history.
+
+        * international/mule-cmds.el (read-char-by-name): Move let-binding of
+        completion-ignore-case in case that var is buffer-local (bug#12615).
+
+2012-10-11  Kenichi Handa  <handa@gnu.org>
+
+        * international/eucjp-ms.el: Re-generated.
+
+2012-10-10  Kenichi Handa  <handa@gnu.org>
+
+        * select.el (xselect--encode-string): If a coding is specified for
+        selection, and that is compatible with COMPOUND_TEXT, use it.
+
+2012-10-10  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (switch-to-buffer-preserve-window-point): New option.
+        (switch-to-buffer):
+        Obey `switch-to-buffer-preserve-window-point' (Bug#4041).
+
 2012-10-09  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * newcomment.el (comment-start-skip, comment-end-skip, comment-end):
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 4dd44bb6f22..7534ce5eaca 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -875,13 +875,11 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
                                (byte-compile-cl-file-p (car xs))))
                 (dolist (s xs)
                   (cond
-                   ((symbolp s)
-                    (unless (memq s old-autoloads)
-                      (push s byte-compile-noruntime-functions)))
                    ((and (consp s) (eq t (car s)))
                     (push (cdr s) old-autoloads))
-                   ((and (consp s) (eq 'autoload (car s)))
-                    (push (cdr s) byte-compile-noruntime-functions)))))))
+                   ((and (consp s) (memq (car s) '(autoload defun)))
+                    (unless (memq (cdr s) old-autoloads)
+                      (push (cdr s) byte-compile-noruntime-functions))))))))
           ;; Go through current-load-list for the locally defined funs.
           (let (old-autoloads)
             (while (and hist-nil-new (not (eq hist-nil-new hist-nil-orig)))
diff --git a/lisp/emacs-lisp/cl-lib.el b/lisp/emacs-lisp/cl-lib.el
index 2eda628e262..122402797e1 100644
--- a/lisp/emacs-lisp/cl-lib.el
+++ b/lisp/emacs-lisp/cl-lib.el
@@ -728,7 +728,8 @@ If ALIST is non-nil, the new pairs are prepended to it."
 ;;;###autoload
 (progn
   ;; Make sure functions defined with cl-defsubst can be inlined even in
-  ;; packages which do not require CL.
+  ;; packages which do not require CL.  We don't put an autoload cookie
+  ;; directly on that function, since those cookies only go to cl-loaddefs.
   (autoload 'cl--defsubst-expand "cl-macs")
   ;; Autoload, so autoload.el and font-lock can use it even when CL
   ;; is not loaded.
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index ef482f8f0e9..f17b29de720 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -621,7 +621,7 @@ FILE is the file where FUNCTION was probably defined."
              ;; If the function is autoloaded, and its docstring has
              ;; key substitution constructs, load the library.
              (doc (progn
-                    (and (autoloadp real-def)
+                    (and (autoloadp real-def) doc-raw
                          help-enable-auto-load
                          (string-match "\\([^\\]=\\|[^=]\\|\\`\\)\\\\[[{<]"
                                        doc-raw)
diff --git a/lisp/international/eucjp-ms.el b/lisp/international/eucjp-ms.el
index a16848a0c7c..6e4e1e798b0 100644
--- a/lisp/international/eucjp-ms.el
+++ b/lisp/international/eucjp-ms.el
@@ -2085,4 +2085,3 @@
               (setcar x (cdr x)) (setcdr x tmp)))
         map)
   (define-translation-table 'eucjp-ms-encode map))
-
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index 58dd24ec8ea..3431c81df88 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -2945,13 +2945,14 @@ at the beginning of the name.
 This function also accepts a hexadecimal number of Unicode code
 point or a number in hash notation, e.g. #o21430 for octal,
 #x2318 for hex, or #10r8984 for decimal."
-  (let* ((completion-ignore-case t)
-         (input (completing-read
-                 prompt
-                 (lambda (string pred action)
-                   (if (eq action 'metadata)
-                       '(metadata (category . unicode-name))
-                     (complete-with-action action (ucs-names) string pred))))))
+  (let ((input
+         (completing-read
+          prompt
+          (lambda (string pred action)
+            (let ((completion-ignore-case t))
+              (if (eq action 'metadata)
+                  '(metadata (category . unicode-name))
+                (complete-with-action action (ucs-names) string pred)))))))
     (cond
      ((string-match-p "\\`[0-9a-fA-F]+\\'" input)
       (string-to-number input 16))
diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el
index c75a1989e8e..a2cb7cb9ee8 100644
--- a/lisp/mail/rmail.el
+++ b/lisp/mail/rmail.el
@@ -4707,7 +4707,7 @@ If prefix argument REVERSE is non-nil, sorts in reverse order.
 
 ;;;### (autoloads (rmail-summary-by-senders rmail-summary-by-topic
 ;;;;;;  rmail-summary-by-regexp rmail-summary-by-recipients rmail-summary-by-labels
-;;;;;;  rmail-summary) "rmailsum" "rmailsum.el" "bef21a376bd5bd59792a20dd86e6ec34")
+;;;;;;  rmail-summary) "rmailsum" "rmailsum.el" "6cafe6b03e187b5836e3c359322b5cbf")
 ;;; Generated autoloads from rmailsum.el
 
 (autoload 'rmail-summary "rmailsum" "\
diff --git a/lisp/mail/rmailsum.el b/lisp/mail/rmailsum.el
index d3a464161cb..612ccbdfd9e 100644
--- a/lisp/mail/rmailsum.el
+++ b/lisp/mail/rmailsum.el
@@ -785,7 +785,7 @@ the message being processed."
                  (setq pos (point))
                  (forward-line 1)
                  (setq str (buffer-substring pos (1- (point))))
-                 (while (looking-at "\\s ")
+                 (while (looking-at "[ \t]")
                    (setq str (concat str " " 
                                      (buffer-substring (match-end 0)
                                                        (line-end-position))))
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 5bf64c18f99..ff805d64024 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -229,15 +229,9 @@
 (defvar python-mode-map
   (let ((map (make-sparse-keymap)))
     ;; Movement
-    (substitute-key-definition 'backward-sentence
-                               'python-nav-backward-block
-                               map global-map)
-    (substitute-key-definition 'forward-sentence
-                               'python-nav-forward-block
-                               map global-map)
-    (substitute-key-definition 'backward-up-list
-                               'python-nav-backward-up-list
-                               map global-map)
+    (define-key map [remap backward-sentence] 'python-nav-backward-block)
+    (define-key map [remap forward-sentence] 'python-nav-forward-block)
+    (define-key map [remap backward-up-list] 'python-nav-backward-up-list)
     (define-key map "\C-c\C-j" 'imenu)
     ;; Indent specific
     (define-key map "\177" 'python-indent-dedent-line-backspace)
@@ -1444,7 +1438,7 @@ DIR is always 1 or -1 and comes sanitized from
              (save-excursion
                (let ((indentation (current-indentation)))
                  (while (and (python-nav-backward-block)
-                             (> (current-indentation) indentation))))
+                             (>= (current-indentation) indentation))))
                (point))))
         (and (> (point) prev-block-pos)
              (goto-char prev-block-pos))))
diff --git a/lisp/select.el b/lisp/select.el
index d3153a0ce0e..54520704261 100644
--- a/lisp/select.el
+++ b/lisp/select.el
@@ -248,7 +248,17 @@ two markers or an overlay.  Otherwise, it is nil."
                                     (setq non-unicode t)
                                   (setq eight-bit t)))))
                       str)
-                (setq type (if non-unicode 'COMPOUND_TEXT
+                (setq type (if (or non-unicode
+                                   (and
+                                    non-latin-1
+                                    ;; If a coding is specified for
+                                    ;; selection, and that is
+                                    ;; compatible with COMPOUND_TEXT,
+                                    ;; use it.
+                                    coding
+                                    (eq (coding-system-get coding :mime-charset)
+                                        'x-ctext)))
+                               'COMPOUND_TEXT
                              (if non-latin-1 'UTF8_STRING
                                (if eight-bit 'C_STRING
                                  'STRING))))))))
diff --git a/lisp/window.el b/lisp/window.el
index f9761366b62..b033f9c26e3 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -5818,6 +5818,26 @@ buffer with the name BUFFER-OR-NAME and return that buffer."
             buffer))
     (other-buffer)))
 
+(defcustom switch-to-buffer-preserve-window-point nil
+  "If non-nil, `switch-to-buffer' tries to preserve `window-point'.
+If this is nil, `switch-to-buffer' displays the buffer at that
+buffer's `point'.  If this is `already-displayed', it tries to
+display the buffer at its pevious position in the selected
+window, provided the buffer is currently displayed in some other
+window on any visible or iconified frame.  If this is t, it
+unconditionally tries to display the buffer at its previous
+position in the selected window.
+
+This variable is ignored if the the buffer is already displayed
+in the selected window or never appeared in it before, or if
+`switch-to-buffer' calls `pop-to-buffer' to display the buffer."
+  :type '(choice
+          (const :tag "Never" nil)
+          (const :tag "If already displayed elsewhere" already-displayed)
+          (const :tag "Always" t))
+  :group 'windows
+  :version "24.3")
+
 (defun switch-to-buffer (buffer-or-name &optional norecord force-same-window)
   "Switch to buffer BUFFER-OR-NAME in the selected window.
 If the selected window cannot display the specified
@@ -5843,6 +5863,10 @@ If optional argument FORCE-SAME-WINDOW is non-nil, the buffer
 must be displayed in the selected window; if that is impossible,
 signal an error rather than calling `pop-to-buffer'.
 
+The option `switch-to-buffer-preserve-window-point' can be used
+to make the buffer appear at its last position in the selected
+window.
+
 Return the buffer switched to."
   (interactive
    (list (read-buffer-to-switch "Switch to buffer: ") nil 'force-same-window))
@@ -5859,7 +5883,19 @@ Return the buffer switched to."
       (if force-same-window
           (user-error "Cannot switch buffers in a dedicated window")
         (pop-to-buffer buffer norecord)))
-     (t (set-window-buffer nil buffer)))
+     (t
+      (let* ((entry (assq buffer (window-prev-buffers)))
+             (displayed (and (eq switch-to-buffer-preserve-window-point
+                                 'already-displayed)
+                             (get-buffer-window buffer 0))))
+        (set-window-buffer nil buffer)
+        (when (and entry
+                   (or (eq switch-to-buffer-preserve-window-point t)
+                       displayed))
+          ;; Try to restore start and point of buffer in the selected
+          ;; window (Bug#4041).
+          (set-window-start (selected-window) (nth 1 entry) t)
+          (set-window-point nil (nth 2 entry))))))
 
     (unless norecord
       (select-window (selected-window)))
diff --git a/src/ChangeLog b/src/ChangeLog
index 25a4e92a1ca..34e730183de 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,134 @@
+2012-10-12  Glenn Morris  <rgm@gnu.org>
+
+        * buffer.c (Fset_buffer): Doc fix.  (Bug#12624)
+
+2012-10-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (Fkill_buffer): Null out the overlay list(s) as well.
+
+        * eval.c (Fautoload): Remember previous autoload status in load-history.
+
+2012-10-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        lread.c, macros.c, marker.c, menu.c, minibuf.c: Use bool for booleans.
+        * lread.c (load_each_byte, new_backquote_flag, readchar)
+        (read_filtered_event, lisp_file_lexically_bound_p)
+        (safe_to_load_version, Fload, complete_filename_p, openp)
+        (build_load_history, readevalloop, read_escape, read1)
+        (string_to_number, read_vector, read_list):
+        * macros.c (Fstart_kbd_macro):
+        * marker.c (CONSIDER):
+        * menu.c (parse_single_submenu, digest_single_submenu)
+        (find_and_return_menu_selection, Fx_popup_menu):
+        * minibuf.c (read_minibuf_noninteractive, read_minibuf)
+        (Ftry_completion):
+        * nsmenu.m (ns_update_menubar, runMenuAt:forFrame:keymaps:):
+        (ns_menu_show):
+        * xmenu.c (set_frame_menubar, create_and_show_popup_menu)
+        (xmenu_show, xdialog_show):
+        Use bool for booleans.
+        * lread.c (safe_to_load_version): Rename from safe_to_load_p,
+        as it's not a predicate.  All uses changed.  Omit unnecessary
+        buffer termination.
+
+2012-10-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * editfns.c (save_excursion_save): Use nil if mark points to nowhere.
+        (save_excursion_restore): Do not restore mark if it was not saved.
+
+2012-10-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * marker.c (cached_modiff): EMACS_INT, not int.
+
+        * w32select.c (waiting_for_input): Declare by including "keyboard.h"
+        instead of having a wrong decl.
+        * nsmenu.m (waiting_for_input): Remove wrong decl.
+
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        keyboard.c, keymap.c: Use bool for booleans.
+        * dispnew.c (sit_for): Distinguish between 3-way display_option
+        and boolean do_display.
+        * keyboard.c (single_kboard, this_command_key_count_reset)
+        (waiting_for_input, echoing, immediate_quit, input_pending)
+        (interrupt_input, interrupts_deferred, pop_kboard)
+        (temporarily_switch_to_single_kboard, ignore_mouse_drag_p)
+        (command_loop_1, adjust_point_for_property)
+        (safe_run_hooks_error, input_polling_used, read_char):
+        (help_char_p, readable_events, kbd_buffer_events_waiting)
+        (kbd_buffer_get_event, timer_check_2, make_lispy_event)
+        (lucid_event_type_list_p, get_input_pending):
+        (gobble_input, menu_separator_name_p, menu_bar_item)
+        (parse_menu_item, parse_tool_bar_item, read_char_x_menu_prompt)
+        (read_char_minibuf_menu_prompt, access_keymap_keyremap)
+        (keyremap_step, test_undefined, read_key_sequence)
+        (detect_input_pending, detect_input_pending_ignore_squeezables)
+        (detect_input_pending_run_timers, requeued_events_pending_p)
+        (quit_throw_to_read_char, Fset_input_interrupt_mode):
+        * keymap.c (get_keymap, keymap_parent, keymap_memberp)
+        (access_keymap_1, access_keymap, map_keymap, get_keyelt)
+        (Fdefine_key, Flookup_key, struct accessible_keymaps_data)
+        (accessible_keymaps_1, Fkey_description, push_key_description):
+        (shadow_lookup, struct where_is_internal_data)
+        (where_is_internal, Fwhere_is_internal, where_is_internal_1)
+        (Fdescribe_buffer_bindings, describe_map_tree, struct describe_map_elt)
+        (describe_map, describe_vector):
+        * menu.c (single_menu_item):
+        * nsmenu.m (ns_update_menubar):
+        * process.c (wait_reading_process_output):
+        * search.c (scan_buffer, scan_newline):
+        Use bool for boolean.
+        * keyboard.c (timers_run, swallow_events)
+        (detect_input_pending_run_timers):
+        * process.c (wait_reading_process_output):
+        Use unsigned for counter where wraparound-on-overflow is desired,
+        since unsigned is guaranteed to have that behavior and signed is not.
+        (read_char): Use ptrdiff_t for string length.
+        (get_input_pending): Remove first argument, since it was always
+        the same pointer-to-int (now pointer-to-boolean) &input_pending,
+        and behave as if it had that value.  Return new value of
+        input_pending.  All callers changed.
+        * keyboard.h (struct kboard): Use unsigned : 1 for boolean member
+        immediate_echo.  Use ptrdiff_t for echo_after_prompt, since it's
+        a string length.
+        * keymap.c (push_key_description): Omit last arg, which was always 1.
+        All callers changed.
+
+        * regex.c (immediate_quit) [emacs]: Remove duplicate decl.
+
+2012-10-10  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in ($(BLD)/dispnew.$(O), $(BLD)/indent.$(O))
+        ($(BLD)/term.$(O)): Update dependencies.
+
+2012-10-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (mark_object): Use meaningful PVEC_NORMAL_VECTOR.
+        * lisp.h (enum pvec_type): Adjust comments and omit explicit
+        initializer for PVEC_NORMAL_VECTOR.
+
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Clean out old termopts cruft.
+        * termopts.h (flow_control, meta_key): Remove unused decls.
+        * dispnew.c, indent.c, nsterm.m, term.c, xsettings.c, xsmfns.c:
+        Don't include termopts.h.
+
+2012-10-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (gc_sweep): Use pointer-to-a-pointer loop for buffers.
+
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * commands.h (immediate_quit): Remove duplicate decl.
+
+2012-10-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (Vfonts_in_cache): Remove, not needed as font.c handles
+        caching.
+        (nsfont_open): Remove setting of Vfonts_in_cache.
+        (syms_of_nsfont): Remove initialization of Vfonts_in_cache
+
 2012-10-09  Eli Zaretskii  <eliz@gnu.org>
 
         * w32fns.c (w32_last_error): Change the return value to DWORD, to
diff --git a/src/alloc.c b/src/alloc.c
index dd3a93ae019..4fd659bd001 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5689,7 +5689,7 @@ mark_object (Lisp_Object arg)
           pvectype = ((ptr->header.size & PVEC_TYPE_MASK)
                       >> PSEUDOVECTOR_SIZE_BITS);
         else
-          pvectype = 0;
+          pvectype = PVEC_NORMAL_VECTOR;
 
         if (pvectype != PVEC_SUBR && pvectype != PVEC_BUFFER)
           CHECK_LIVE (live_vector_p);
@@ -6311,19 +6311,14 @@ gc_sweep (void)
 
   /* Free all unmarked buffers */
   {
-    register struct buffer *buffer = all_buffers, *prev = 0, *next;
+    register struct buffer *buffer, **bprev = &all_buffers;
 
     total_buffers = 0;
-    while (buffer)
+    for (buffer = all_buffers; buffer; buffer = *bprev)
       if (!VECTOR_MARKED_P (buffer))
         {
-          if (prev)
-            prev->header.next = buffer->header.next;
-          else
-            all_buffers = buffer->header.next.buffer;
-          next = buffer->header.next.buffer;
+          *bprev = buffer->header.next.buffer;
           lisp_free (buffer);
-          buffer = next;
         }
       else
         {
@@ -6331,7 +6326,7 @@ gc_sweep (void)
           /* Do not use buffer_(set|get)_intervals here.  */
           buffer->text->intervals = balance_intervals (buffer->text->intervals);
           total_buffers++;
-          prev = buffer, buffer = buffer->header.next.buffer;
+          bprev = &buffer->header.next.buffer;
         }
   }
 
diff --git a/src/buffer.c b/src/buffer.c
index 425d05ca790..861a89b5a0f 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -897,6 +897,8 @@ delete_all_overlays (struct buffer *b)
 {
   struct Lisp_Overlay *ov, *next;
 
+  /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
+     markers, we have an unneeded O(N^2) behavior here.  */
   for (ov = b->overlays_before; ov; ov = next)
     {
       drop_overlay (b, ov);
@@ -1886,16 +1888,19 @@ cleaning up all windows currently displaying the buffer to be killed. */)
 
   if (b->base_buffer)
     {
-      /* Unchain all markers that belong to this indirect buffer.
-         Don't unchain the markers that belong to the base buffer
-         or its other indirect buffers.  */
-      for (m = BUF_MARKERS (b); m; )
-        {
-          struct Lisp_Marker *next = m->next;
-          if (m->buffer == b)
-            unchain_marker (m);
-          m = next;
-        }
+      { /* Unchain all markers that belong to this indirect buffer.
+           Don't unchain the markers that belong to the base buffer
+           or its other indirect buffers.  */
+        struct Lisp_Marker **mp;
+        for (mp = &BUF_MARKERS (b); *mp; )
+          {
+            struct Lisp_Marker *m = *mp;
+            if (m->buffer == b)
+              *mp = m->next;
+            else
+              mp = &m->next;
+          }
+      }
     }
   else
     {
@@ -1911,8 +1916,12 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       BUF_MARKERS (b) = NULL;
       set_buffer_intervals (b, NULL);
 
-      /* Perhaps we should explicitly free the interval tree here... */
+      /* Perhaps we should explicitly free the interval tree here...  */
     }
+  /* Since we've unlinked the markers, the overlays can't be here any more
+     either.  */
+  b->overlays_before = NULL;
+  b->overlays_after = NULL;
 
   /* Reset the local variables, so that this buffer's local values
      won't be protected from GC.  They would be protected
@@ -2176,7 +2185,7 @@ set_buffer_temp (struct buffer *b)
 DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
        doc: /* Make buffer BUFFER-OR-NAME current for editing operations.
 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.  See
-also `save-excursion' when you want to make a buffer current
+also `with-current-buffer' when you want to make a buffer current
 temporarily.  This function does not display the buffer, so its effect
 ends when the current command terminates.  Use `switch-to-buffer' or
 `pop-to-buffer' to switch buffers permanently.  */)
diff --git a/src/commands.h b/src/commands.h
index 36f600cee01..510fce0e182 100644
--- a/src/commands.h
+++ b/src/commands.h
@@ -36,9 +36,6 @@ extern Lisp_Object control_x_map;
    events until a non-ASCII event is acceptable as input.  */
 extern Lisp_Object unread_switch_frame;
 
-/* Nonzero means ^G can quit instantly */
-extern int immediate_quit;
-
 /* Nonzero if input is coming from the keyboard */
 
 #define INTERACTIVE (NILP (Vexecuting_kbd_macro) && !noninteractive)
diff --git a/src/dispnew.c b/src/dispnew.c
index 6f8fb10b41d..0956e3f2905 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -26,7 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "lisp.h"
 #include "termchar.h"
-#include "termopts.h"
 /* cm.h must come after dispextern.h on Windows.  */
 #include "dispextern.h"
 #include "cm.h"
@@ -5919,15 +5918,16 @@ additional wait period, in milliseconds; this is for backwards compatibility.
    TIMEOUT is number of seconds to wait (float or integer),
    or t to wait forever.
    READING is true if reading input.
-   If DO_DISPLAY is >0 display process output while waiting.
-   If DO_DISPLAY is >1 perform an initial redisplay before waiting.
+   If DISPLAY_OPTION is >0 display process output while waiting.
+   If DISPLAY_OPTION is >1 perform an initial redisplay before waiting.
 */
 
 Lisp_Object
-sit_for (Lisp_Object timeout, bool reading, int do_display)
+sit_for (Lisp_Object timeout, bool reading, int display_option)
 {
   intmax_t sec;
   int nsec;
+  bool do_display = display_option > 0;
 
   swallow_events (do_display);
 
@@ -5935,7 +5935,7 @@ sit_for (Lisp_Object timeout, bool reading, int do_display)
       || !NILP (Vexecuting_kbd_macro))
     return Qnil;
 
-  if (do_display >= 2)
+  if (display_option > 1)
     redisplay_preserve_echo_area (2);
 
   if (INTEGERP (timeout))
diff --git a/src/editfns.c b/src/editfns.c
index fc6465a3d46..19fad7130a7 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -819,9 +819,13 @@ save_excursion_save (void)
 {
   bool visible = (XBUFFER (XWINDOW (selected_window)->buffer)
                   == current_buffer);
+  /* Do not copy the mark if it points to nowhere.  */
+  Lisp_Object mark = (XMARKER (BVAR (current_buffer, mark))->buffer
+                      ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
+                      : Qnil);
 
   return Fcons (Fpoint_marker (),
-                Fcons (Fcopy_marker (BVAR (current_buffer, mark), Qnil),
+                Fcons (mark,
                        Fcons (visible ? Qt : Qnil,
                               Fcons (BVAR (current_buffer, mark_active),
                                      selected_window))));
@@ -856,9 +860,14 @@ save_excursion_restore (Lisp_Object info)
   info = XCDR (info);
   tem = XCAR (info);
   omark = Fmarker_position (BVAR (current_buffer, mark));
-  Fset_marker (BVAR (current_buffer, mark), tem, Fcurrent_buffer ());
-  nmark = Fmarker_position (tem);
-  unchain_marker (XMARKER (tem));
+  if (NILP (tem))
+    unchain_marker (XMARKER (BVAR (current_buffer, mark)));
+  else
+    {
+      Fset_marker (BVAR (current_buffer, mark), tem, Fcurrent_buffer ());
+      nmark = Fmarker_position (tem);
+      unchain_marker (XMARKER (tem));
+    }
 
   /* visible */
   info = XCDR (info);
diff --git a/src/eval.c b/src/eval.c
index 4d200fbc2bd..975204da017 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1876,9 +1876,11 @@ this does nothing and returns nil.  */)
   CHECK_STRING (file);
 
   /* If function is defined and not as an autoload, don't override.  */
-  if (!EQ (XSYMBOL (function)->function, Qunbound)
-      && !(CONSP (XSYMBOL (function)->function)
-           && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
+  if ((CONSP (XSYMBOL (function)->function)
+       && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
+    /* Remember that the function was already an autoload.  */
+    LOADHIST_ATTACH (Fcons (Qt, function));
+  else if (!EQ (XSYMBOL (function)->function, Qunbound))
     return Qnil;
 
   if (NILP (Vpurify_flag))
diff --git a/src/indent.c b/src/indent.c
index b368a7aeb09..81a63455ecb 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -30,7 +30,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "window.h"
 #include "termchar.h"
-#include "termopts.h"
 #include "disptab.h"
 #include "intervals.h"
 #include "dispextern.h"
diff --git a/src/keyboard.c b/src/keyboard.c
index 2a37e510ba4..68656d527e8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -86,8 +86,8 @@ KBOARD *initial_kboard;
 KBOARD *current_kboard;
 KBOARD *all_kboards;
 
-/* Nonzero in the single-kboard state, 0 in the any-kboard state.  */
-static int single_kboard;
+/* True in the single-kboard state, false in the any-kboard state.  */
+static bool single_kboard;
 
 /* Non-nil disable property on a command means
    do not execute it; call disabled-command-function's value instead.  */
@@ -113,9 +113,9 @@ static Lisp_Object recent_keys;
 Lisp_Object this_command_keys;
 ptrdiff_t this_command_key_count;
 
-/* 1 after calling Freset_this_command_lengths.
-   Usually it is 0.  */
-static int this_command_key_count_reset;
+/* True after calling Freset_this_command_lengths.
+   Usually it is false.  */
+static bool this_command_key_count_reset;
 
 /* This vector is used as a buffer to record the events that were actually read
    by read_key_sequence.  */
@@ -140,11 +140,11 @@ static ptrdiff_t before_command_echo_length;
 static sys_jmp_buf getcjmp;
 
 /* True while doing kbd input.  */
-int waiting_for_input;
+bool waiting_for_input;
 
 /* True while displaying for echoing.   Delays C-g throwing.  */
 
-static int echoing;
+static bool echoing;
 
 /* Non-null means we can start echoing at the next input pause even
    though there is something in the echo area.  */
@@ -163,8 +163,8 @@ struct kboard *echo_kboard;
 
 Lisp_Object echo_message_buffer;
 
-/* Nonzero means C-g should cause immediate error-signal.  */
-int immediate_quit;
+/* True means C-g should cause immediate error-signal.  */
+bool immediate_quit;
 
 /* Character that causes a quit.  Normally C-g.
 
@@ -270,7 +270,7 @@ static Lisp_Object Qhelp_form_show;
 static FILE *dribble;
 
 /* Nonzero if input is available.  */
-int input_pending;
+bool input_pending;
 
 /* Circular buffer for pre-read keyboard input.  */
 
@@ -375,18 +375,18 @@ static ptrdiff_t echo_length (void);
 static Lisp_Object Qpolling_period;
 
 /* Incremented whenever a timer is run.  */
-int timers_run;
+unsigned timers_run;
 
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
    happens.  */
 EMACS_TIME *input_available_clear_time;
 
-/* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
-   Default is 1 if INTERRUPT_INPUT is defined.  */
-int interrupt_input;
+/* True means use SIGIO interrupts; false means use CBREAK mode.
+   Default is true if INTERRUPT_INPUT is defined.  */
+bool interrupt_input;
 
 /* Nonzero while interrupts are temporarily deferred during redisplay.  */
-int interrupts_deferred;
+bool interrupts_deferred;
 
 /* If we support a window system, turn on the code to poll periodically
    to detect C-g.  It isn't actually used when doing interrupt input.  */
@@ -414,10 +414,10 @@ static EMACS_TIME timer_last_idleness_start_time;
 /* Function for init_keyboard to call with no args (if nonzero).  */
 static void (*keyboard_init_hook) (void);
 
-static void get_input_pending (int *, int);
-static int readable_events (int);
+static bool get_input_pending (int);
+static bool readable_events (int);
 static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
-                                            Lisp_Object, int *);
+                                            Lisp_Object, bool *);
 static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
                                                   Lisp_Object *);
 static Lisp_Object make_lispy_event (struct input_event *);
@@ -431,7 +431,7 @@ static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object,
                                         Lisp_Object, const char *const *,
                                         Lisp_Object *, ptrdiff_t);
 static Lisp_Object make_lispy_switch_frame (Lisp_Object);
-static int help_char_p (Lisp_Object);
+static bool help_char_p (Lisp_Object);
 static void save_getcjmp (sys_jmp_buf);
 static void restore_getcjmp (sys_jmp_buf);
 static Lisp_Object apply_modifiers (int, Lisp_Object);
@@ -441,7 +441,7 @@ static Lisp_Object restore_kboard_configuration (Lisp_Object);
 static void deliver_input_available_signal (int signo);
 #endif
 static void handle_interrupt (bool);
-static _Noreturn void quit_throw_to_read_char (int);
+static _Noreturn void quit_throw_to_read_char (bool);
 static void process_special_events (void);
 static void timer_start_idle (void);
 static void timer_stop_idle (void);
@@ -519,7 +519,7 @@ echo_char (Lisp_Object c)
 
       if (INTEGERP (c))
         {
-          ptr = push_key_description (XINT (c), ptr, 1);
+          ptr = push_key_description (XINT (c), ptr);
         }
       else if (SYMBOLP (c))
         {
@@ -928,7 +928,7 @@ pop_kboard (void)
 {
   struct terminal *t;
   struct kboard_stack *p = kboard_stack;
-  int found = 0;
+  bool found = 0;
   for (t = terminal_list; t; t = t->next_terminal)
     {
       if (t->kboard == p->kboard)
@@ -961,7 +961,7 @@ pop_kboard (void)
 void
 temporarily_switch_to_single_kboard (struct frame *f)
 {
-  int was_locked = single_kboard;
+  bool was_locked = single_kboard;
   if (was_locked)
     {
       if (f != NULL && FRAME_KBOARD (f) != current_kboard)
@@ -1060,12 +1060,7 @@ cmd_error (Lisp_Object data)
   Vprint_length = old_length;
 
   Vquit_flag = Qnil;
-
   Vinhibit_quit = Qnil;
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-  if (command_loop_level == 0 && minibuf_level == 0)
-    any_kboard_state ();
-#endif
 
   return make_number (0);
 }
@@ -1152,12 +1147,6 @@ command_loop (void)
     while (1)
       {
         internal_catch (Qtop_level, top_level_1, Qnil);
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-        /* Reset single_kboard in case top-level set it while
-           evaluating an -f option, or we are stuck there for some
-           other reason.  */
-        any_kboard_state ();
-#endif
         internal_catch (Qtop_level, command_loop_2, Qnil);
         executing_kbd_macro = Qnil;
 
@@ -1268,8 +1257,7 @@ tracking_off (Lisp_Object old_value)
       if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW))
         {
           redisplay_preserve_echo_area (6);
-          get_input_pending (&input_pending,
-                             READABLE_EVENTS_DO_TIMERS_NOW);
+          get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
         }
     }
   return Qnil;
@@ -1304,7 +1292,7 @@ usage: (track-mouse BODY...)  */)
 #if !defined HAVE_WINDOW_SYSTEM || defined USE_GTK || defined HAVE_NS
 static
 #endif
-int ignore_mouse_drag_p;
+bool ignore_mouse_drag_p;
 
 static FRAME_PTR
 some_mouse_moved (void)
@@ -1332,9 +1320,9 @@ some_mouse_moved (void)
    sans error-handling encapsulation.  */
 
 static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
-                              int, int, int);
+                              bool, bool, bool);
 void safe_run_hooks (Lisp_Object);
-static void adjust_point_for_property (ptrdiff_t, int);
+static void adjust_point_for_property (ptrdiff_t, bool);
 
 /* Cancel hourglass from protect_unwind.
    ARG is not used.  */
@@ -1362,10 +1350,7 @@ command_loop_1 (void)
   int i;
   EMACS_INT prev_modiff = 0;
   struct buffer *prev_buffer = NULL;
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-  int was_locked = single_kboard;
-#endif
-  int already_adjusted = 0;
+  bool already_adjusted = 0;
 
   kset_prefix_arg (current_kboard, Qnil);
   kset_last_prefix_arg (current_kboard, Qnil);
@@ -1734,10 +1719,6 @@ command_loop_1 (void)
       if (!NILP (KVAR (current_kboard, defining_kbd_macro))
           && NILP (KVAR (current_kboard, Vprefix_arg)))
         finalize_kbd_macro_chars ();
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-      if (!was_locked)
-        any_kboard_state ();
-#endif
     }
 }
 
@@ -1747,7 +1728,7 @@ command_loop_1 (void)
    LAST_PT is the last position of point.  */
 
 static void
-adjust_point_for_property (ptrdiff_t last_pt, int modified)
+adjust_point_for_property (ptrdiff_t last_pt, bool modified)
 {
   ptrdiff_t beg, end;
   Lisp_Object val, overlay, tmp;
@@ -1755,7 +1736,7 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified)
      suppress the point adjustment for automatic composition so that a
      user can keep inserting another character at point or keep
      deleting characters around point.  */
-  int check_composition = ! modified, check_display = 1, check_invisible = 1;
+  bool check_composition = ! modified, check_display = 1, check_invisible = 1;
   ptrdiff_t orig_pt = PT;
 
   /* FIXME: cycling is probably not necessary because these properties
@@ -1794,7 +1775,8 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified)
       check_display = 0;
       if (check_invisible && PT > BEGV && PT < ZV)
         {
-          int inv, ellipsis = 0;
+          int inv;
+          bool ellipsis = 0;
           beg = end = PT;
 
           /* Find boundaries `beg' and `end' of the invisible area, if any.  */
@@ -1923,7 +1905,7 @@ safe_run_hooks_error (Lisp_Object error_data)
   if (SYMBOLP (hook))
     {
       Lisp_Object val;
-      int found = 0;
+      bool found = 0;
       Lisp_Object newval = Qnil;
       for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
         if (EQ (fun, XCAR (val)))
@@ -2053,9 +2035,9 @@ start_polling (void)
 #endif
 }
 
-/* Nonzero if we are using polling to handle input asynchronously.  */
+/* True if we are using polling to handle input asynchronously.  */
 
-int
+bool
 input_polling_used (void)
 {
 #ifdef POLL_FOR_INPUT
@@ -2231,7 +2213,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
 
 /* Input of single characters from keyboard */
 
-static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu,
+static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
                                          EMACS_TIME *end_time);
 static void record_char (Lisp_Object c);
 
@@ -2268,9 +2250,9 @@ do { if (polling_stopped_here) start_polling ();	\
    not to run input methods, but in other respects to act as if
    not reading a key sequence.
 
-   If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
-   if we used a mouse menu to read the input, or zero otherwise.  If
-   USED_MOUSE_MENU is null, we don't dereference it.
+   If USED_MOUSE_MENU is non-null, then set *USED_MOUSE_MENU to true
+   if we used a mouse menu to read the input, or false otherwise.  If
+   USED_MOUSE_MENU is null, don't dereference it.
 
    Value is -2 when we find input on another keyboard.  A second call
    to read_char will read it.
@@ -2284,7 +2266,7 @@ do { if (polling_stopped_here) start_polling ();	\
 Lisp_Object
 read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
            Lisp_Object prev_event,
-           int *used_mouse_menu, EMACS_TIME *end_time)
+           bool *used_mouse_menu, EMACS_TIME *end_time)
 {
   Lisp_Object c;
   ptrdiff_t jmpcount;
@@ -2293,9 +2275,9 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
   Lisp_Object tem, save;
   volatile Lisp_Object previous_echo_area_message;
   volatile Lisp_Object also_record;
-  volatile int reread;
+  volatile bool reread;
   struct gcpro gcpro1, gcpro2;
-  int volatile polling_stopped_here = 0;
+  bool volatile polling_stopped_here = 0;
   struct kboard *orig_kboard = current_kboard;
 
   also_record = Qnil;
@@ -2331,7 +2313,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
 
   if (CONSP (Vunread_command_events))
     {
-      int was_disabled = 0;
+      bool was_disabled = 0;
 
       c = XCAR (Vunread_command_events);
       Vunread_command_events = XCDR (Vunread_command_events);
@@ -2433,7 +2415,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
   /* if redisplay was requested */
   if (commandflag >= 0)
     {
-      int echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
+      bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
 
         /* If there is pending input, process any events which are not
            user-visible, such as X selection_request events.  */
@@ -2865,12 +2847,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
   if (!NILP (tem))
     {
       struct buffer *prev_buffer = current_buffer;
-#if 0 /* This shouldn't be necessary anymore. --lorentey  */
-      int was_locked = single_kboard;
-      ptrdiff_t count = SPECPDL_INDEX ();
-      record_single_kboard_state ();
-#endif
-
       last_input_event = c;
       Fcommand_execute (tem, Qnil, Fvector (1, &last_input_event), Qt);
 
@@ -2881,13 +2857,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
            example banishing the mouse under mouse-avoidance-mode.  */
         timer_resume_idle ();
 
-#if 0 /* This shouldn't be necessary anymore. --lorentey  */
-      /* Resume allowing input from any kboard, if that was true before.  */
-      if (!was_locked)
-        any_kboard_state ();
-      unbind_to (count, Qnil);
-#endif
-
       if (current_buffer != prev_buffer)
         {
           /* The command may have changed the keymaps.  Pretend there
@@ -2995,15 +2964,15 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
     {
       Lisp_Object keys;
       ptrdiff_t key_count;
-      int key_count_reset;
+      bool key_count_reset;
       struct gcpro gcpro1;
       ptrdiff_t count = SPECPDL_INDEX ();
 
       /* Save the echo status.  */
-      int saved_immediate_echo = current_kboard->immediate_echo;
+      bool saved_immediate_echo = current_kboard->immediate_echo;
       struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
       Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
-      int saved_echo_after_prompt = current_kboard->echo_after_prompt;
+      ptrdiff_t saved_echo_after_prompt = current_kboard->echo_after_prompt;
 
 #if 0
       if (before_command_restore_flag)
@@ -3204,9 +3173,9 @@ record_menu_key (Lisp_Object c)
   num_input_events++;
 }
 
-/* Return 1 if should recognize C as "the help character".  */
+/* Return true if should recognize C as "the help character".  */
 
-static int
+static bool
 help_char_p (Lisp_Object c)
 {
   Lisp_Object tail;
@@ -3378,7 +3347,7 @@ restore_getcjmp (sys_jmp_buf temp)
 
 /* Return true if there are any events in the queue that read-char
    would return.  If this returns false, a read-char would block.  */
-static int
+static bool
 readable_events (int flags)
 {
   if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
@@ -3717,15 +3686,14 @@ discard_mouse_events (void)
 }
 
 
-/* Return non-zero if there are any real events waiting in the event
+/* Return true if there are any real events waiting in the event
    buffer, not counting `NO_EVENT's.
 
-   If DISCARD is non-zero, discard NO_EVENT events at the front of
-   the input queue, possibly leaving the input queue empty if there
-   are no real input events.  */
+   Discard NO_EVENT events at the front of the input queue, possibly
+   leaving the input queue empty if there are no real input events.  */
 
-int
-kbd_buffer_events_waiting (int discard)
+bool
+kbd_buffer_events_waiting (void)
 {
   struct input_event *sp;
 
@@ -3737,9 +3705,7 @@ kbd_buffer_events_waiting (int discard)
         sp = kbd_buffer;
     }
 
-  if (discard)
-    kbd_fetch_ptr = sp;
-
+  kbd_fetch_ptr = sp;
   return sp != kbd_store_ptr && sp->kind != NO_EVENT;
 }
 
@@ -3761,7 +3727,7 @@ clear_event (struct input_event *event)
 
 static Lisp_Object
 kbd_buffer_get_event (KBOARD **kbp,
-                      int *used_mouse_menu,
+                      bool *used_mouse_menu,
                       EMACS_TIME *end_time)
 {
   Lisp_Object obj;
@@ -4216,14 +4182,14 @@ process_special_events (void)
    are ripe, and return, without reading any user-visible events.  */
 
 void
-swallow_events (int do_display)
+swallow_events (bool do_display)
 {
-  int old_timers_run;
+  unsigned old_timers_run;
 
   process_special_events ();
 
   old_timers_run = timers_run;
-  get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+  get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
 
   if (timers_run != old_timers_run && do_display)
     redisplay_preserve_echo_area (7);
@@ -4350,7 +4316,7 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
       EMACS_TIME difference;
       EMACS_TIME timer_difference = invalid_emacs_time ();
       EMACS_TIME idle_timer_difference = invalid_emacs_time ();
-      int ripe, timer_ripe = 0, idle_timer_ripe = 0;
+      bool ripe, timer_ripe = 0, idle_timer_ripe = 0;
 
       /* Set TIMER and TIMER_DIFFERENCE
          based on the next ordinary timer.
@@ -5454,7 +5420,7 @@ make_lispy_event (struct input_event *event)
 #endif
       {
         int button = event->code;
-        int is_double;
+        bool is_double;
         Lisp_Object position;
         Lisp_Object *start_pos_ptr;
         Lisp_Object start_pos;
@@ -5735,7 +5701,7 @@ make_lispy_event (struct input_event *event)
           struct frame *fr;
           int fuzz;
           int symbol_num;
-          int is_double;
+          bool is_double;
 
           if (WINDOWP (event->frame_or_window))
             fr = XFRAME (XWINDOW (event->frame_or_window)->frame);
@@ -6677,11 +6643,11 @@ parse_solitary_modifier (Lisp_Object symbol)
   return 0;
 }
 
-/* Return 1 if EVENT is a list whose elements are all integers or symbols.
+/* Return true if EVENT is a list whose elements are all integers or symbols.
    Such a list is not valid as an event,
    but it can be a Lucid-style event type list.  */
 
-int
+bool
 lucid_event_type_list_p (Lisp_Object object)
 {
   Lisp_Object tail;
@@ -6706,8 +6672,10 @@ lucid_event_type_list_p (Lisp_Object object)
   return NILP (tail);
 }
 
-/* Store into *addr a value nonzero if terminal input chars are available.
-   Serves the purpose of ioctl (0, FIONREAD, addr)
+/* Return true if terminal input chars are available.
+   Also, store the return value into INPUT_PENDING.
+
+   Serves the purpose of ioctl (0, FIONREAD, ...)
    but works even if FIONREAD does not exist.
    (In fact, this may actually read some input.)
 
@@ -6718,19 +6686,21 @@ lucid_event_type_list_p (Lisp_Object object)
    If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
    movements and toolkit scroll bar thumb drags.  */
 
-static void
-get_input_pending (int *addr, int flags)
+static bool
+get_input_pending (int flags)
 {
   /* First of all, have we already counted some input?  */
-  *addr = (!NILP (Vquit_flag) || readable_events (flags));
+  input_pending = (!NILP (Vquit_flag) || readable_events (flags));
 
   /* If input is being read as it arrives, and we have none, there is none.  */
-  if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
-    return;
+  if (!input_pending && (!interrupt_input || interrupts_deferred))
+    {
+      /* Try to read some input and see how much we get.  */
+      gobble_input ();
+      input_pending = (!NILP (Vquit_flag) || readable_events (flags));
+    }
 
-  /* Try to read some input and see how much we get.  */
-  gobble_input ();
-  *addr = (!NILP (Vquit_flag) || readable_events (flags));
+  return input_pending;
 }
 
 /* Put a BUFFER_SWITCH_EVENT in the buffer
@@ -6780,7 +6750,7 @@ int
 gobble_input (void)
 {
   int nread = 0;
-  int err = 0;
+  bool err = 0;
   struct terminal *t;
 
   /* Store pending user signal events, if any.  */
@@ -7350,9 +7320,9 @@ static const char* separator_names[] = {
   0,
 };
 
-/* Return non-zero if LABEL specifies a separator.  */
+/* Return true if LABEL specifies a separator.  */
 
-int
+bool
 menu_separator_name_p (const char *label)
 {
   if (!label)
@@ -7527,6 +7497,7 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
 {
   struct gcpro gcpro1;
   int i;
+  bool parsed;
   Lisp_Object tem;
 
   if (EQ (item, Qundefined))
@@ -7558,9 +7529,9 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
      parse_menu_item, so that if it turns out it wasn't a menu item,
      it still correctly hides any further menu item.  */
   GCPRO1 (key);
-  i = parse_menu_item (item, 1);
+  parsed = parse_menu_item (item, 1);
   UNGCPRO;
-  if (!i)
+  if (!parsed)
     return;
 
   item = AREF (item_properties, ITEM_PROPERTY_DEF);
@@ -7636,7 +7607,7 @@ menu_item_eval_property (Lisp_Object sexpr)
    parse_menu_item returns true if the item is a menu item and false
    otherwise.  */
 
-int
+bool
 parse_menu_item (Lisp_Object item, int inmenubar)
 {
   Lisp_Object def, tem, item_string, start;
@@ -7936,7 +7907,7 @@ static Lisp_Object QCrtl;
 
 static void init_tool_bar_items (Lisp_Object);
 static void process_tool_bar_item (Lisp_Object, Lisp_Object, Lisp_Object, void*);
-static int parse_tool_bar_item (Lisp_Object, Lisp_Object);
+static bool parse_tool_bar_item (Lisp_Object, Lisp_Object);
 static void append_tool_bar_item (void);
 
 
@@ -8069,7 +8040,7 @@ set_prop (ptrdiff_t idx, Lisp_Object val)
 
 
 /* Parse a tool bar item specification ITEM for key KEY and return the
-   result in tool_bar_item_properties.  Value is zero if ITEM is
+   result in tool_bar_item_properties.  Value is false if ITEM is
    invalid.
 
    ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
@@ -8114,12 +8085,13 @@ set_prop (ptrdiff_t idx, Lisp_Object val)
 
    A text label to show with the tool bar button if labels are enabled.  */
 
-static int
+static bool
 parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
 {
   Lisp_Object filter = Qnil;
   Lisp_Object caption;
-  int i, have_label = 0;
+  int i;
+  bool have_label = 0;
 
   /* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
      Rule out items that aren't lists, don't start with
@@ -8376,9 +8348,9 @@ append_tool_bar_item (void)
    PREV_EVENT is the previous input event, or nil if we are reading
    the first event of a key sequence.
 
-   If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
-   if we used a mouse menu to read the input, or zero otherwise.  If
-   USED_MOUSE_MENU is null, we don't dereference it.
+   If USED_MOUSE_MENU is non-null, set *USED_MOUSE_MENU to true
+   if we used a mouse menu to read the input, or false otherwise.  If
+   USED_MOUSE_MENU is null, don't dereference it.
 
    The prompting is done based on the prompt-string of the map
    and the strings associated with various map elements.
@@ -8391,7 +8363,7 @@ append_tool_bar_item (void)
 
 static Lisp_Object
 read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
-                         Lisp_Object prev_event, int *used_mouse_menu)
+                         Lisp_Object prev_event, bool *used_mouse_menu)
 {
 #ifdef HAVE_MENUS
   ptrdiff_t mapno;
@@ -8485,7 +8457,7 @@ read_char_minibuf_menu_prompt (int commandflag,
   /* FIXME: Use the minibuffer's frame width.  */
   ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
   ptrdiff_t idx = -1;
-  int nobindings = 1;
+  bool nobindings = 1;
   Lisp_Object rest, vector;
   char *menu;
 
@@ -8533,7 +8505,7 @@ read_char_minibuf_menu_prompt (int commandflag,
   /* Present the documented bindings, a line at a time.  */
   while (1)
     {
-      int notfirst = 0;
+      bool notfirst = 0;
       ptrdiff_t i = nlength;
       Lisp_Object obj;
       Lisp_Object orig_defn_macro;
@@ -8589,8 +8561,8 @@ read_char_minibuf_menu_prompt (int commandflag,
               /* Ignore the element if it has no prompt string.  */
               if (INTEGERP (event) && parse_menu_item (elt, -1))
                 {
-                  /* 1 if the char to type matches the string.  */
-                  int char_matches;
+                  /* True if the char to type matches the string.  */
+                  bool char_matches;
                   Lisp_Object upcased_event, downcased_event;
                   Lisp_Object desc = Qnil;
                   Lisp_Object s
@@ -8642,7 +8614,7 @@ read_char_minibuf_menu_prompt (int commandflag,
                           i += 2;
                         }
                       notfirst = 1;
-                      nobindings = 0 ;
+                      nobindings = 0;
 
                       /* If the char to type doesn't match the string's
                          first char, explicitly show what char to type.  */
@@ -8776,14 +8748,14 @@ typedef struct keyremap
 
 /* Lookup KEY in MAP.
    MAP is a keymap mapping keys to key vectors or functions.
-   If the mapping is a function and DO_FUNCTION is non-zero, then
+   If the mapping is a function and DO_FUNCALL is true,
    the function is called with PROMPT as parameter and its return
    value is used as the return value of this function (after checking
    that it is indeed a vector).  */
 
 static Lisp_Object
 access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
-                        int do_funcall)
+                        bool do_funcall)
 {
   Lisp_Object next;
 
@@ -8822,15 +8794,15 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
    BUFSIZE is its maximum size.
    FKEY is a pointer to the keyremap structure to use.
    INPUT is the index of the last element in KEYBUF.
-   DOIT if non-zero says that the remapping can actually take place.
+   DOIT if true says that the remapping can actually take place.
    DIFF is used to return the number of keys added/removed by the remapping.
    PARENT is the root of the keymap.
    PROMPT is the prompt to use if the remapping happens through a function.
-   The return value is non-zero if the remapping actually took place.  */
+   Return true if the remapping actually took place.  */
 
-static int
+static bool
 keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
-               int input, int doit, int *diff, Lisp_Object prompt)
+               int input, bool doit, int *diff, Lisp_Object prompt)
 {
   Lisp_Object next, key;
 
@@ -8884,7 +8856,7 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
   return 0;
 }
 
-static int
+static bool
 test_undefined (Lisp_Object binding)
 {
   return (EQ (binding, Qundefined)
@@ -8926,13 +8898,13 @@ test_undefined (Lisp_Object binding)
    off the switch-frame event until later; the next call to
    read_char will return it.
 
-   If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
+   If FIX_CURRENT_BUFFER, we restore current_buffer
    from the selected window's buffer.  */
 
 static int
 read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
-                   int dont_downcase_last, int can_return_switch_frame,
-                   int fix_current_buffer)
+                   bool dont_downcase_last, bool can_return_switch_frame,
+                   bool fix_current_buffer)
 {
   Lisp_Object from_string;
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -8965,7 +8937,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      key sequence.  */
   Lisp_Object orig_keymap;
 
-  /* 1 if we have already considered switching to the local-map property
+  /* Positive if we have already considered switching to the local-map property
      of the place where a mouse click occurred.  */
   int localized_local_map = 0;
 
@@ -9005,10 +8977,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   /* Likewise, for key_translation_map and input-decode-map.  */
   keyremap keytran, indec;
 
-  /* Non-zero if we are trying to map a key by changing an upper-case
+  /* True if we are trying to map a key by changing an upper-case
      letter to lower case, or a shifted function key to an unshifted
      one.  */
-  int shift_translated = 0;
+  bool shift_translated = 0;
 
   /* If we receive a `switch-frame' or `select-window' event in the middle of
      a key sequence, we put it off for later.
@@ -9024,7 +8996,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   int original_uppercase_position = -1;
 
   /* Gets around Microsoft compiler limitations.  */
-  int dummyflag = 0;
+  bool dummyflag = 0;
 
   struct buffer *starting_buffer;
 
@@ -9186,7 +9158,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          : (/* indec.start < t || fkey.start < t || */ keytran.start < t))
     {
       Lisp_Object key;
-      int used_mouse_menu = 0;
+      bool used_mouse_menu = 0;
 
       /* Where the last real key started.  If we need to throw away a
          key that has expanded into more than one element of keybuf
@@ -9280,7 +9252,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                    return.  Any better way to fix this? -- cyd  */
                 || (interrupted_kboard != current_kboard))
               {
-                int found = 0;
+                bool found = 0;
                 struct kboard *k;
 
                 for (k = all_kboards; k; k = k->next_kboard)
@@ -9834,7 +9806,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       while (indec.end < t)
         {
           struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-          int done, diff;
+          bool done;
+          int diff;
 
           GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
           done = keyremap_step (keybuf, bufsize, &indec, max (t, mock_input),
@@ -9868,7 +9841,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
         while (fkey.end < indec.start)
           {
             struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-            int done, diff;
+            bool done;
+            int diff;
 
             GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
             done = keyremap_step (keybuf, bufsize, &fkey,
@@ -9897,7 +9871,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       while (keytran.end < fkey.start)
         {
           struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-          int done, diff;
+          bool done;
+          int diff;
 
           GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
           done = keyremap_step (keybuf, bufsize, &keytran, max (t, mock_input),
@@ -10283,38 +10258,32 @@ a special event, so ignore the prefix argument and don't clear it.  */)
 
 
 
-/* Return nonzero if input events are pending.  */
+/* Return true if input events are pending.  */
 
-int
+bool
 detect_input_pending (void)
 {
-  if (!input_pending)
-    get_input_pending (&input_pending, 0);
-
-  return input_pending;
+  return input_pending || get_input_pending (0);
 }
 
-/* Return nonzero if input events other than mouse movements are
+/* Return true if input events other than mouse movements are
    pending.  */
 
-int
+bool
 detect_input_pending_ignore_squeezables (void)
 {
-  if (!input_pending)
-    get_input_pending (&input_pending, READABLE_EVENTS_IGNORE_SQUEEZABLES);
-
-  return input_pending;
+  return input_pending || get_input_pending (READABLE_EVENTS_IGNORE_SQUEEZABLES);
 }
 
-/* Return nonzero if input events are pending, and run any pending timers.  */
+/* Return true if input events are pending, and run any pending timers.  */
 
-int
-detect_input_pending_run_timers (int do_display)
+bool
+detect_input_pending_run_timers (bool do_display)
 {
-  int old_timers_run = timers_run;
+  unsigned old_timers_run = timers_run;
 
   if (!input_pending)
-    get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+    get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
 
   if (old_timers_run != timers_run && do_display)
     {
@@ -10345,13 +10314,13 @@ clear_input_pending (void)
   input_pending = 0;
 }
 
-/* Return nonzero if there are pending requeued events.
+/* Return true if there are pending requeued events.
    This isn't used yet.  The hope is to make wait_reading_process_output
    call it, and return if it runs Lisp code that unreads something.
    The problem is, kbd_buffer_get_event needs to be fixed to know what
    to do in that case.  It isn't trivial.  */
 
-int
+bool
 requeued_events_pending_p (void)
 {
   return (!NILP (Vunread_command_events));
@@ -10372,10 +10341,9 @@ if there is a doubt, the value is t.  */)
   /* Process non-user-visible events (Bug#10195).  */
   process_special_events ();
 
-  get_input_pending (&input_pending,
-                     READABLE_EVENTS_DO_TIMERS_NOW
-                     | READABLE_EVENTS_FILTER_EVENTS);
-  return input_pending > 0 ? Qt : Qnil;
+  return (get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW
+                             | READABLE_EVENTS_FILTER_EVENTS)
+          ? Qt : Qnil);
 }
 
 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
@@ -10881,7 +10849,7 @@ handle_interrupt (bool in_signal_handler)
 /* Handle a C-g by making read_char return C-g.  */
 
 static void
-quit_throw_to_read_char (int from_signal)
+quit_throw_to_read_char (bool from_signal)
 {
   /* When not called from a signal handler it is safe to call
      Lisp.  */
@@ -10911,7 +10879,7 @@ otherwise Emacs uses CBREAK mode.
 See also `current-input-mode'.  */)
   (Lisp_Object interrupt)
 {
-  int new_interrupt_input;
+  bool new_interrupt_input;
 #ifdef USABLE_SIGIO
 #ifdef HAVE_X_WINDOWS
   if (x_display_list != NULL)
diff --git a/src/keyboard.h b/src/keyboard.h
index d78c27fbf9b..e57c8cc7193 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -169,12 +169,12 @@ struct kboard
        reading from this KBOARD again until more input arrives.  */
     char kbd_queue_has_data;
 
-    /* Nonzero means echo each character as typed.  */
-    char immediate_echo;
+    /* True means echo each character as typed.  */
+    unsigned immediate_echo : 1;
 
     /* If we have echoed a prompt string specified by the user,
        this is its length in characters.  Otherwise this is -1.  */
-    char echo_after_prompt;
+    ptrdiff_t echo_after_prompt;
   };
 
 KEYBOARD_INLINE void
@@ -463,14 +463,14 @@ extern Lisp_Object Qhelp_echo;
 extern Lisp_Object Qmode_line, Qvertical_line, Qheader_line;
 
 /* True while doing kbd input.  */
-extern int waiting_for_input;
+extern bool waiting_for_input;
 
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
    happens.  */
 extern EMACS_TIME *input_available_clear_time;
 
 #if defined HAVE_WINDOW_SYSTEM && !defined USE_GTK && !defined HAVE_NS
-extern int ignore_mouse_drag_p;
+extern bool ignore_mouse_drag_p;
 #endif
 
 /* The primary selection.  */
@@ -482,7 +482,7 @@ struct input_event;
 extern Lisp_Object parse_modifiers (Lisp_Object);
 extern Lisp_Object reorder_modifiers (Lisp_Object);
 extern Lisp_Object read_char (int, ptrdiff_t, Lisp_Object *, Lisp_Object,
-                              int *, EMACS_TIME *);
+                              bool *, EMACS_TIME *);
 extern int parse_solitary_modifier (Lisp_Object symbol);
 
 
@@ -506,10 +506,10 @@ extern Time last_event_timestamp;
 
 extern int quit_char;
 
-extern int timers_run;
+extern unsigned int timers_run;
 
-extern int menu_separator_name_p (const char *);
-extern int parse_menu_item (Lisp_Object, int);
+extern bool menu_separator_name_p (const char *);
+extern bool parse_menu_item (Lisp_Object, int);
 
 extern void init_kboard (KBOARD *);
 extern void delete_kboard (KBOARD *);
@@ -524,15 +524,15 @@ extern void start_polling (void);
 extern void stop_polling (void);
 extern void set_poll_suppress_count (int);
 extern int gobble_input (void);
-extern int input_polling_used (void);
+extern bool input_polling_used (void);
 extern void clear_input_pending (void);
-extern int requeued_events_pending_p (void);
+extern bool requeued_events_pending_p (void);
 extern void bind_polling_period (int);
 extern int make_ctrl_char (int) ATTRIBUTE_CONST;
 extern void stuff_buffered_input (Lisp_Object);
 extern void clear_waiting_for_input (void);
-extern void swallow_events (int);
-extern int lucid_event_type_list_p (Lisp_Object);
+extern void swallow_events (bool);
+extern bool lucid_event_type_list_p (Lisp_Object);
 extern void kbd_buffer_store_event (struct input_event *);
 extern void kbd_buffer_store_event_hold (struct input_event *,
                                          struct input_event *);
@@ -544,7 +544,7 @@ extern void gen_help_event (Lisp_Object, Lisp_Object, Lisp_Object,
                             Lisp_Object, ptrdiff_t);
 extern void kbd_buffer_store_help_event (Lisp_Object, Lisp_Object);
 extern Lisp_Object menu_item_eval_property (Lisp_Object);
-extern int  kbd_buffer_events_waiting (int);
+extern bool kbd_buffer_events_waiting (void);
 extern void add_user_signal (int, const char *);
 
 extern int tty_read_avail_input (struct terminal *, struct input_event *);
diff --git a/src/keymap.c b/src/keymap.c
index 6ea142651bf..fbdd31e0de3 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -99,12 +99,12 @@ static void describe_command (Lisp_Object, Lisp_Object);
 static void describe_translation (Lisp_Object, Lisp_Object);
 static void describe_map (Lisp_Object, Lisp_Object,
                           void (*) (Lisp_Object, Lisp_Object),
-                          int, Lisp_Object, Lisp_Object*, int, int);
+                          bool, Lisp_Object, Lisp_Object*, bool, bool);
 static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
-                             void (*) (Lisp_Object, Lisp_Object), int,
-                             Lisp_Object, Lisp_Object, int, int);
+                             void (*) (Lisp_Object, Lisp_Object), bool,
+                             Lisp_Object, Lisp_Object, bool, bool);
 static void silly_event_symbol_error (Lisp_Object);
-static Lisp_Object get_keyelt (Lisp_Object, int);
+static Lisp_Object get_keyelt (Lisp_Object, bool);
 
 /* Keymap object support - constructors and predicates.                 */
 
@@ -207,15 +207,12 @@ when reading a key-sequence to be looked-up in this keymap.  */)
 /* Check that OBJECT is a keymap (after dereferencing through any
    symbols).  If it is, return it.
 
-   If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
+   If AUTOLOAD and if OBJECT is a symbol whose function value
    is an autoload form, do the autoload and try again.
-   If AUTOLOAD is nonzero, callers must assume GC is possible.
-
-   If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
-   is zero as well), return Qt.
+   If AUTOLOAD, callers must assume GC is possible.
 
    ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
-   If ERROR_IF_NOT_KEYMAP is non-zero, signal an error; otherwise,
+   If ERROR_IF_NOT_KEYMAP, signal an error; otherwise,
    just return Qnil.
 
    Note that most of the time, we don't want to pursue autoloads.
@@ -224,11 +221,11 @@ when reading a key-sequence to be looked-up in this keymap.  */)
    but it seems to me that only read_key_sequence, Flookup_key, and
    Fdefine_key should cause keymaps to be autoloaded.
 
-   This function can GC when AUTOLOAD is non-zero, because it calls
+   This function can GC when AUTOLOAD is true, because it calls
    Fautoload_do_load which can GC.  */
 
 Lisp_Object
-get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
+get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
 {
   Lisp_Object tem;
 
@@ -280,7 +277,7 @@ get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
    We assume that KEYMAP is a valid keymap.  */
 
 static Lisp_Object
-keymap_parent (Lisp_Object keymap, int autoload)
+keymap_parent (Lisp_Object keymap, bool autoload)
 {
   Lisp_Object list;
 
@@ -307,7 +304,7 @@ If KEYMAP has no parent, return nil.  */)
 }
 
 /* Check whether MAP is one of MAPS parents.  */
-static int
+static bool
 keymap_memberp (Lisp_Object map, Lisp_Object maps)
 {
   if (NILP (map)) return 0;
@@ -365,19 +362,20 @@ Return PARENT.  PARENT should be nil or another keymap.  */)
 
    MAP must be a keymap or a list of keymaps.
 
-   If T_OK is non-zero, bindings for Qt are treated as default
+   If T_OK, bindings for Qt are treated as default
    bindings; any key left unmentioned by other tables and bindings is
    given the binding of Qt.
 
-   If T_OK is zero, bindings for Qt are not treated specially.
+   If not T_OK, bindings for Qt are not treated specially.
 
    If NOINHERIT, don't accept a subkeymap found in an inherited keymap.
 
-   Returns Qunbound if no binding was found (and returns Qnil if a nil
+   Return Qunbound if no binding was found (and return Qnil if a nil
    binding was found).  */
 
 static Lisp_Object
-access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
+access_keymap_1 (Lisp_Object map, Lisp_Object idx,
+                 bool t_ok, bool noinherit, bool autoload)
 {
   /* If idx is a list (some sort of mouse click, perhaps?),
      the index we want to use is the car of the list, which
@@ -547,7 +545,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int
 
 Lisp_Object
 access_keymap (Lisp_Object map, Lisp_Object idx,
-               int t_ok, int noinherit, int autoload)
+               bool t_ok, bool noinherit, bool autoload)
 {
   Lisp_Object val = access_keymap_1 (map, idx, t_ok, noinherit, autoload);
   return EQ (val, Qunbound) ? Qnil : val;
@@ -630,9 +628,10 @@ map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
 }
 
 /* Same as map_keymap_internal, but traverses parent keymaps as well.
-   A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded.  */
+   AUTOLOAD indicates that autoloaded keymaps should be loaded.  */
 void
-map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
+map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args,
+            void *data, bool autoload)
 {
   struct gcpro gcpro1;
   GCPRO1 (args);
@@ -711,13 +710,13 @@ usage: (map-keymap FUNCTION KEYMAP)  */)
    Also if OBJECT has a menu string as the first element,
    remove that.  Also remove a menu help string as second element.
 
-   If AUTOLOAD is nonzero, load autoloadable keymaps
+   If AUTOLOAD, load autoloadable keymaps
    that are referred to with indirection.
 
    This can GC because menu_item_eval_property calls Feval.  */
 
 static Lisp_Object
-get_keyelt (Lisp_Object object, int autoload)
+get_keyelt (Lisp_Object object, bool autoload)
 {
   while (1)
     {
@@ -1114,10 +1113,10 @@ binding is altered.  If there is no binding for KEY, the new pair
 binding KEY to DEF is added at the front of KEYMAP.  */)
   (Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
 {
-  register ptrdiff_t idx;
-  register Lisp_Object c;
-  register Lisp_Object cmd;
-  int metized = 0;
+  ptrdiff_t idx;
+  Lisp_Object c;
+  Lisp_Object cmd;
+  bool metized = 0;
   int meta_bit;
   ptrdiff_t length;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1271,11 +1270,11 @@ third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
 recognize the default bindings, just as `read-key-sequence' does.  */)
   (Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
 {
-  register ptrdiff_t idx;
-  register Lisp_Object cmd;
-  register Lisp_Object c;
+  ptrdiff_t idx;
+  Lisp_Object cmd;
+  Lisp_Object c;
   ptrdiff_t length;
-  int t_ok = !NILP (accept_default);
+  bool t_ok = !NILP (accept_default);
   struct gcpro gcpro1, gcpro2;
 
   GCPRO2 (keymap, key);
@@ -1887,7 +1886,7 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_
 struct accessible_keymaps_data {
   Lisp_Object maps, tail, thisseq;
   /* Does the current sequence end in the meta-prefix-char?  */
-  int is_metized;
+  bool is_metized;
 };
 
 static void
@@ -1898,7 +1897,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
   Lisp_Object maps = d->maps;
   Lisp_Object tail = d->tail;
   Lisp_Object thisseq = d->thisseq;
-  int is_metized = d->is_metized && INTEGERP (key);
+  bool is_metized = d->is_metized && INTEGERP (key);
   Lisp_Object tem;
 
   cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
@@ -2060,7 +2059,7 @@ The `kbd' macro is an approximate inverse of this.  */)
   Lisp_Object sep = build_string (" ");
   Lisp_Object key;
   Lisp_Object result;
-  int add_meta = 0;
+  bool add_meta = 0;
   USE_SAFE_ALLOCA;
 
   if (!NILP (prefix))
@@ -2155,9 +2154,10 @@ The `kbd' macro is an approximate inverse of this.  */)
 
 
 char *
-push_key_description (EMACS_INT ch, char *p, int force_multibyte)
+push_key_description (EMACS_INT ch, char *p)
 {
-  int c, c2, tab_as_ci;
+  int c, c2;
+  bool tab_as_ci;
 
   /* Clear all the meaningless bits above the meta bit.  */
   c = ch & (meta_modifier | ~ - meta_modifier);
@@ -2256,21 +2256,12 @@ push_key_description (EMACS_INT ch, char *p, int force_multibyte)
       *p++ = 'P';
       *p++ = 'C';
     }
-  else if (c < 128
-           || (NILP (BVAR (current_buffer, enable_multibyte_characters))
-               && SINGLE_BYTE_CHAR_P (c)
-               && !force_multibyte))
-    {
-      *p++ = c;
-    }
+  else if (c < 128)
+    *p++ = c;
   else
     {
       /* Now we are sure that C is a valid character code.  */
-      if (NILP (BVAR (current_buffer, enable_multibyte_characters))
-          && ! force_multibyte)
-        *p++ = multibyte_char_to_unibyte (c);
-      else
-        p += CHAR_STRING (c, (unsigned char *) p);
+      p += CHAR_STRING (c, (unsigned char *) p);
     }
 
   return p;
@@ -2299,9 +2290,8 @@ around function keys and event symbols.  */)
 
   if (INTEGERP (key))           /* Normal character.  */
     {
-      char tem[KEY_DESCRIPTION_SIZE], *p;
-
-      p = push_key_description (XINT (key), tem, 1);
+      char tem[KEY_DESCRIPTION_SIZE];
+      char *p = push_key_description (XINT (key), tem);
       *p = 0;
       return make_specified_string (tem, -1, p - tem, 1);
     }
@@ -2429,7 +2419,7 @@ static void where_is_internal_1 (Lisp_Object key, Lisp_Object binding,
 
 static Lisp_Object
 shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
-               int remap)
+               bool remap)
 {
   Lisp_Object tail, value;
 
@@ -2461,7 +2451,7 @@ static Lisp_Object Vmouse_events;
 
 struct where_is_internal_data {
   Lisp_Object definition, this, last;
-  int last_is_meta, noindirect;
+  bool last_is_meta, noindirect;
   Lisp_Object sequences;
 };
 
@@ -2474,7 +2464,7 @@ struct where_is_internal_data {
 
 static Lisp_Object
 where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
-                   int noindirect, int nomenus)
+                   bool noindirect, bool nomenus)
 {
   Lisp_Object maps = Qnil;
   Lisp_Object found;
@@ -2523,7 +2513,7 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
          [M-CHAR] sequences, check if last character of the sequence
          is the meta-prefix char.  */
       Lisp_Object last;
-      int last_is_meta;
+      bool last_is_meta;
 
       this = Fcar (XCAR (maps));
       map  = Fcdr (XCAR (maps));
@@ -2606,7 +2596,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
     /* Actually relevant bindings.  */
   Lisp_Object found = Qnil;
   /* 1 means ignore all menu bindings entirely.  */
-  int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
+  bool nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
   /* List of sequences found via remapping.  Keep them in a separate
      variable, so as to push them later, since we prefer
@@ -2615,7 +2605,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
   /* Whether or not we're handling remapped sequences.  This is needed
      because remapping is not done recursively by Fcommand_remapping: you
      can't remap a remapped command.  */
-  int remapped = 0;
+  bool remapped = 0;
   Lisp_Object tem = Qnil;
 
   /* Refresh the C version of the modifier preference.  */
@@ -2767,10 +2757,10 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi
 {
   struct where_is_internal_data *d = data; /* Cast! */
   Lisp_Object definition = d->definition;
-  int noindirect = d->noindirect;
+  bool noindirect = d->noindirect;
   Lisp_Object this = d->this;
   Lisp_Object last = d->last;
-  int last_is_meta = d->last_is_meta;
+  bool last_is_meta = d->last_is_meta;
   Lisp_Object sequence;
 
   /* Search through indirections unless that's not wanted.  */
@@ -2821,8 +2811,8 @@ The optional argument MENUS, if non-nil, says to mention menu bindings.
   (Lisp_Object buffer, Lisp_Object prefix, Lisp_Object menus)
 {
   Lisp_Object outbuf, shadow;
-  int nomenu = NILP (menus);
-  register Lisp_Object start1;
+  bool nomenu = NILP (menus);
+  Lisp_Object start1;
   struct gcpro gcpro1;
 
   const char *alternate_heading
@@ -2857,10 +2847,10 @@ You type        Translation\n\
                 alternate_heading = 0;
               }
 
-            bufend = push_key_description (translate[c], buf, 1);
+            bufend = push_key_description (translate[c], buf);
             insert (buf, bufend - buf);
             Findent_to (make_number (16), make_number (1));
-            bufend = push_key_description (c, buf, 1);
+            bufend = push_key_description (c, buf);
             insert (buf, bufend - buf);
 
             insert ("\n", 1);
@@ -2977,34 +2967,34 @@ You type        Translation\n\
 
 /* Insert a description of the key bindings in STARTMAP,
     followed by those of all maps reachable through STARTMAP.
-   If PARTIAL is nonzero, omit certain "uninteresting" commands
+   If PARTIAL, omit certain "uninteresting" commands
     (such as `undefined').
    If SHADOW is non-nil, it is a list of maps;
     don't mention keys which would be shadowed by any of them.
    PREFIX, if non-nil, says mention only keys that start with PREFIX.
    TITLE, if not 0, is a string to insert at the beginning.
    TITLE should not end with a colon or a newline; we supply that.
-   If NOMENU is not 0, then omit menu-bar commands.
+   If NOMENU, then omit menu-bar commands.
 
-   If TRANSL is nonzero, the definitions are actually key translations
+   If TRANSL, the definitions are actually key translations
    so print strings and vectors differently.
 
-   If ALWAYS_TITLE is nonzero, print the title even if there are no maps
+   If ALWAYS_TITLE, print the title even if there are no maps
    to look through.
 
-   If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
+   If MENTION_SHADOW, then when something is shadowed by SHADOW,
    don't omit it; instead, mention it but say it is shadowed.
 
    Any inserted text ends in two newlines (used by `help-make-xrefs').  */
 
 void
-describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
-                   Lisp_Object prefix, const char *title, int nomenu, int transl,
-                   int always_title, int mention_shadow)
+describe_map_tree (Lisp_Object startmap, bool partial, Lisp_Object shadow,
+                   Lisp_Object prefix, const char *title, bool nomenu,
+                   bool transl, bool always_title, bool mention_shadow)
 {
   Lisp_Object maps, orig_maps, seen, sub_shadows;
   struct gcpro gcpro1, gcpro2, gcpro3;
-  int something = 0;
+  bool something = 0;
   const char *key_heading
     = "\
 key             binding\n\
@@ -3179,7 +3169,12 @@ describe_translation (Lisp_Object definition, Lisp_Object args)
    into an array of `struct describe_map_elt',
    then sorts them by the events.  */
 
-struct describe_map_elt { Lisp_Object event; Lisp_Object definition; int shadowed; };
+struct describe_map_elt
+{
+  Lisp_Object event;
+  Lisp_Object definition;
+  bool shadowed;
+};
 
 /* qsort comparison function for sorting `struct describe_map_elt' by
    the event field.  */
@@ -3209,14 +3204,14 @@ describe_map_compare (const void *aa, const void *bb)
 static void
 describe_map (Lisp_Object map, Lisp_Object prefix,
               void (*elt_describer) (Lisp_Object, Lisp_Object),
-              int partial, Lisp_Object shadow,
-              Lisp_Object *seen, int nomenu, int mention_shadow)
+              bool partial, Lisp_Object shadow,
+              Lisp_Object *seen, bool nomenu, bool mention_shadow)
 {
   Lisp_Object tail, definition, event;
   Lisp_Object tem;
   Lisp_Object suppress;
   Lisp_Object kludge;
-  int first = 1;
+  bool first = 1;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   /* These accumulate the values from sparse keymap bindings,
@@ -3258,7 +3253,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
                          1, mention_shadow);
       else if (CONSP (XCAR (tail)))
         {
-          int this_shadowed = 0;
+          bool this_shadowed = 0;
 
           event = XCAR (XCAR (tail));
 
@@ -3428,7 +3423,7 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
    of bytes that lead to the character set or portion of a character
    set described by this chartable.
 
-   If PARTIAL is nonzero, it means do not mention suppressed commands
+   If PARTIAL, it means do not mention suppressed commands
    (that assumes the vector is in a keymap).
 
    SHADOW is a list of keymaps that shadow this map.
@@ -3448,8 +3443,8 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
 static void
 describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
                  void (*elt_describer) (Lisp_Object, Lisp_Object),
-                 int partial, Lisp_Object shadow, Lisp_Object entire_map,
-                 int keymap_p, int mention_shadow)
+                 bool partial, Lisp_Object shadow, Lisp_Object entire_map,
+                 bool keymap_p, bool mention_shadow)
 {
   Lisp_Object definition;
   Lisp_Object tem2;
@@ -3457,7 +3452,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
   int i;
   Lisp_Object suppress;
   Lisp_Object kludge;
-  int first = 1;
+  bool first = 1;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   /* Range of elements to be handled.  */
   int from, to, stop;
@@ -3497,7 +3492,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
 
   for (i = from; ; i++)
     {
-      int this_shadowed = 0;
+      bool this_shadowed = 0;
       int range_beg, range_end;
       Lisp_Object val;
 
diff --git a/src/keymap.h b/src/keymap.h
index 5ed70c67b85..c704ee0b050 100644
--- a/src/keymap.h
+++ b/src/keymap.h
@@ -34,11 +34,11 @@ extern Lisp_Object Qkeymap, Qmenu_bar;
 extern Lisp_Object Qremap;
 extern Lisp_Object Qmenu_item;
 extern Lisp_Object current_global_map;
-extern char *push_key_description (EMACS_INT, char *, int);
-extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, int, int, int);
-extern Lisp_Object get_keymap (Lisp_Object, int, int);
-extern void describe_map_tree (Lisp_Object, int, Lisp_Object, Lisp_Object,
-                              const char *, int, int, int, int);
+extern char *push_key_description (EMACS_INT, char *);
+extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, bool, bool, bool);
+extern Lisp_Object get_keymap (Lisp_Object, bool, bool);
+extern void describe_map_tree (Lisp_Object, bool, Lisp_Object, Lisp_Object,
+                               const char *, bool, bool, bool, bool);
 extern ptrdiff_t current_minor_maps (Lisp_Object **, Lisp_Object **);
 extern void initial_define_key (Lisp_Object, int, const char *);
 extern void initial_define_lispy_key (Lisp_Object, const char *, const char *);
@@ -47,7 +47,8 @@ extern void keys_of_keymap (void);
 
 typedef void (*map_keymap_function_t)
      (Lisp_Object key, Lisp_Object val, Lisp_Object args, void* data);
-extern void map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object largs, void* cargs, int autoload);
+extern void map_keymap (Lisp_Object, map_keymap_function_t, Lisp_Object,
+                        void *, bool);
 extern void map_keymap_canonical (Lisp_Object map,
                                   map_keymap_function_t fun,
                                   Lisp_Object args, void *data);
diff --git a/src/lisp.h b/src/lisp.h
index 7812e58782b..756d08fda33 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -345,15 +345,11 @@ static ptrdiff_t const PSEUDOVECTOR_FLAG
       = PSEUDOVECTOR_FLAG;
 
 /* In a pseudovector, the size field actually contains a word with one
-   PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
-   indicate the actual type.
-   We use a bitset, even tho only one of the bits can be set at any
-   particular time just so as to be able to use micro-optimizations such as
-   testing membership of a particular subset of pseudovectors in Fequal.
-   It is not crucial, but there are plenty of bits here, so why not do it?  */
+   PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
+   with PVEC_TYPE_MASK to indicate the actual type.  */
 enum pvec_type
 {
-  PVEC_NORMAL_VECTOR = 0,       /* Unused!  */
+  PVEC_NORMAL_VECTOR,
   PVEC_FREE,
   PVEC_PROCESS,
   PVEC_FRAME,
@@ -3031,7 +3027,7 @@ extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t);
   } while (0)
 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
                   Lisp_Object *, Lisp_Object);
-Lisp_Object string_to_number (char const *, int, int);
+extern Lisp_Object string_to_number (char const *, int, bool);
 extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
                          Lisp_Object);
 extern void dir_warning (const char *, Lisp_Object);
@@ -3202,9 +3198,9 @@ extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
 extern ptrdiff_t scan_buffer (int, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                              ptrdiff_t *, int);
+                              ptrdiff_t *, bool);
 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                               EMACS_INT, int);
+                               EMACS_INT, bool);
 extern ptrdiff_t find_next_newline (ptrdiff_t, int);
 extern ptrdiff_t find_next_newline_no_quit (ptrdiff_t, ptrdiff_t);
 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t);
@@ -3247,7 +3243,7 @@ extern Lisp_Object Qdisabled, QCfilter;
 extern Lisp_Object Qup, Qdown, Qbottom;
 extern Lisp_Object Qtop;
 extern Lisp_Object last_undo_boundary;
-extern int input_pending;
+extern bool input_pending;
 extern Lisp_Object menu_bar_items (Lisp_Object);
 extern Lisp_Object tool_bar_items (Lisp_Object, int *);
 extern void discard_mouse_events (void);
@@ -3255,9 +3251,9 @@ extern void discard_mouse_events (void);
 void handle_input_available_signal (int);
 #endif
 extern Lisp_Object pending_funcalls;
-extern int detect_input_pending (void);
-extern int detect_input_pending_ignore_squeezables (void);
-extern int detect_input_pending_run_timers (int);
+extern bool detect_input_pending (void);
+extern bool detect_input_pending_ignore_squeezables (void);
+extern bool detect_input_pending_run_timers (bool);
 extern void safe_run_hooks (Lisp_Object);
 extern void cmd_error_internal (Lisp_Object, const char *);
 extern Lisp_Object command_loop_1 (void);
@@ -3336,7 +3332,7 @@ extern bool running_asynch_code;
 extern Lisp_Object QCtype, Qlocal;
 extern Lisp_Object Qprocessp;
 extern void kill_buffer_processes (Lisp_Object);
-extern int wait_reading_process_output (intmax_t, int, int, int,
+extern int wait_reading_process_output (intmax_t, int, int, bool,
                                         Lisp_Object,
                                         struct Lisp_Process *,
                                         int);
@@ -3568,7 +3564,8 @@ extern char *emacs_root_dir (void);
    Used during startup to detect startup of dumped Emacs.  */
 extern bool initialized;
 
-extern int immediate_quit;          /* Nonzero means ^G can quit instantly.  */
+/* True means ^G can quit instantly.  */
+extern bool immediate_quit;
 
 extern void *xmalloc (size_t);
 extern void *xzalloc (size_t);
diff --git a/src/lread.c b/src/lread.c
index a2b6d1f26d9..dbbde694cf6 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -95,10 +95,10 @@ static Lisp_Object Qload_in_progress;
    It must be set to nil before all top-level calls to read0.  */
 static Lisp_Object read_objects;
 
-/* Nonzero means READCHAR should read bytes one by one (not character)
+/* True means READCHAR should read bytes one by one (not character)
    when READCHARFUN is Qget_file_char or Qget_emacs_mule_file_char.
-   This is set to 1 by read1 temporarily while handling #@NUMBER.  */
-static int load_each_byte;
+   This is set by read1 temporarily while handling #@NUMBER.  */
+static bool load_each_byte;
 
 /* List of descriptors now open for Fload.  */
 static Lisp_Object load_descriptor_list;
@@ -135,11 +135,11 @@ static ptrdiff_t prev_saved_doc_string_length;
 /* This is the file position that string came from.  */
 static file_offset prev_saved_doc_string_position;
 
-/* Nonzero means inside a new-style backquote
+/* True means inside a new-style backquote
    with no surrounding parentheses.
-   Fread initializes this to zero, so we need not specbind it
+   Fread initializes this to false, so we need not specbind it
    or worry about what happens to it when there is an error.  */
-static int new_backquote_flag;
+static bool new_backquote_flag;
 static Lisp_Object Qold_style_backquotes;
 
 /* A list of file names for files being loaded in Fload.  Used to
@@ -150,7 +150,7 @@ static Lisp_Object Vloads_in_progress;
 static int read_emacs_mule_char (int, int (*) (int, Lisp_Object),
                                  Lisp_Object);
 
-static void readevalloop (Lisp_Object, FILE*, Lisp_Object, int,
+static void readevalloop (Lisp_Object, FILE *, Lisp_Object, bool,
                           Lisp_Object, Lisp_Object,
                           Lisp_Object, Lisp_Object);
 static Lisp_Object load_unwind (Lisp_Object);
@@ -192,7 +192,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
   int (*readbyte) (int, Lisp_Object);
   unsigned char buf[MAX_MULTIBYTE_LENGTH];
   int i, len;
-  int emacs_mule_encoding = 0;
+  bool emacs_mule_encoding = 0;
 
   if (multibyte)
     *multibyte = 0;
@@ -546,10 +546,10 @@ read_emacs_mule_char (int c, int (*readbyte) (int, Lisp_Object), Lisp_Object rea
 static Lisp_Object read_internal_start (Lisp_Object, Lisp_Object,
                                         Lisp_Object);
 static Lisp_Object read0 (Lisp_Object);
-static Lisp_Object read1 (Lisp_Object, int *, int);
+static Lisp_Object read1 (Lisp_Object, int *, bool);
 
-static Lisp_Object read_list (int, Lisp_Object);
-static Lisp_Object read_vector (Lisp_Object, int);
+static Lisp_Object read_list (bool, Lisp_Object);
+static Lisp_Object read_vector (Lisp_Object, bool);
 
 static Lisp_Object substitute_object_recurse (Lisp_Object, Lisp_Object,
                                               Lisp_Object);
@@ -562,28 +562,28 @@ static void substitute_in_interval (INTERVAL, Lisp_Object);
 
 /* Read input events until we get one that's acceptable for our purposes.
 
-   If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
+   If NO_SWITCH_FRAME, switch-frame events are stashed
    until we get a character we like, and then stuffed into
    unread_switch_frame.
 
-   If ASCII_REQUIRED is non-zero, we check function key events to see
+   If ASCII_REQUIRED, check function key events to see
    if the unmodified version of the symbol has a Qascii_character
    property, and use that character, if present.
 
-   If ERROR_NONASCII is non-zero, we signal an error if the input we
-   get isn't an ASCII character with modifiers.  If it's zero but
-   ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
+   If ERROR_NONASCII, signal an error if the input we
+   get isn't an ASCII character with modifiers.  If it's false but
+   ASCII_REQUIRED is true, just re-read until we get an ASCII
    character.
 
-   If INPUT_METHOD is nonzero, we invoke the current input method
+   If INPUT_METHOD, invoke the current input method
    if the character warrants that.
 
-   If SECONDS is a number, we wait that many seconds for input, and
+   If SECONDS is a number, wait that many seconds for input, and
    return Qnil if no input arrives within that time.  */
 
 static Lisp_Object
-read_filtered_event (int no_switch_frame, int ascii_required,
-                     int error_nonascii, int input_method, Lisp_Object seconds)
+read_filtered_event (bool no_switch_frame, bool ascii_required,
+                     bool error_nonascii, bool input_method, Lisp_Object seconds)
 {
   Lisp_Object val, delayed_switch_frame;
   EMACS_TIME end_time;
@@ -767,7 +767,7 @@ DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
    positioned following the first line, if it is a comment or #! line,
    otherwise nothing is read.  */
 
-static int
+static bool
 lisp_file_lexically_bound_p (Lisp_Object readcharfun)
 {
   int ch = READCHAR;
@@ -797,11 +797,11 @@ lisp_file_lexically_bound_p (Lisp_Object readcharfun)
   else
     /* Look for an appropriate file-variable in the first line.  */
     {
-      int rv = 0;
+      bool rv = 0;
       enum {
         NOMINAL, AFTER_FIRST_DASH, AFTER_ASTERIX,
       } beg_end_state = NOMINAL;
-      int in_file_vars = 0;
+      bool in_file_vars = 0;
 
 #define UPDATE_BEG_END_STATE(ch)                                \
   if (beg_end_state == NOMINAL)                                 \
@@ -897,20 +897,17 @@ lisp_file_lexically_bound_p (Lisp_Object readcharfun)
    because of an incompatible change in the byte compiler.  */
 
 static int
-safe_to_load_p (int fd)
+safe_to_load_version (int fd)
 {
   char buf[512];
   int nbytes, i;
-  int safe_p = 1;
   int version = 1;
 
   /* Read the first few bytes from the file, and look for a line
      specifying the byte compiler version used.  */
-  nbytes = emacs_read (fd, buf, sizeof buf - 1);
+  nbytes = emacs_read (fd, buf, sizeof buf);
   if (nbytes > 0)
     {
-      buf[nbytes] = '\0';
-
       /* Skip to the next newline, skipping over the initial `ELC'
          with NUL bytes following it, but note the version.  */
       for (i = 0; i < nbytes && buf[i] != '\n'; ++i)
@@ -920,13 +917,11 @@ safe_to_load_p (int fd)
       if (i >= nbytes
           || fast_c_string_match_ignore_case (Vbytecomp_version_regexp,
                                               buf + i, nbytes - i) < 0)
-        safe_p = 0;
+        version = 0;
     }
-  if (safe_p)
-    safe_p = version;
 
   lseek (fd, 0, SEEK_SET);
-  return safe_p;
+  return version;
 }
 
 
@@ -1030,12 +1025,12 @@ Return t if the file exists and loads successfully.  */)
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3;
   Lisp_Object found, efound, hist_file_name;
-  /* 1 means we printed the ".el is newer" message.  */
-  int newer = 0;
-  /* 1 means we are loading a compiled file.  */
-  int compiled = 0;
+  /* True means we printed the ".el is newer" message.  */
+  bool newer = 0;
+  /* True means we are loading a compiled file.  */
+  bool compiled = 0;
   Lisp_Object handler;
-  int safe_p = 1;
+  bool safe_p = 1;
   const char *fmode = "r";
   Lisp_Object tmp[2];
   int version;
@@ -1190,7 +1185,7 @@ Return t if the file exists and loads successfully.  */)
   record_unwind_protect (load_warn_old_style_backquotes, file);
 
   if (!memcmp (SDATA (found) + SBYTES (found) - 4, ".elc", 4)
-      || (fd >= 0 && (version = safe_to_load_p (fd)) > 0))
+      || (fd >= 0 && (version = safe_to_load_version (fd)) > 0))
     /* Load .elc files directly, but not when they are
        remote and have no handler!  */
     {
@@ -1202,7 +1197,7 @@ Return t if the file exists and loads successfully.  */)
           GCPRO3 (file, found, hist_file_name);
 
           if (version < 0
-              && ! (version = safe_to_load_p (fd)))
+              && ! (version = safe_to_load_version (fd)))
             {
               safe_p = 0;
               if (!load_dangerous_libraries)
@@ -1394,10 +1389,10 @@ close_load_descs (void)
 #endif
 }
 
-static int
+static bool
 complete_filename_p (Lisp_Object pathname)
 {
-  register const unsigned char *s = SDATA (pathname);
+  const unsigned char *s = SDATA (pathname);
   return (IS_DIRECTORY_SEP (s[0])
           || (SCHARS (pathname) > 2
               && IS_DEVICE_SEP (s[1]) && IS_DIRECTORY_SEP (s[2])));
@@ -1447,11 +1442,11 @@ static Lisp_Object Qdir_ok;
 int
 openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *storeptr, Lisp_Object predicate)
 {
-  register int fd;
+  int fd;
   ptrdiff_t fn_size = 100;
   char buf[100];
-  register char *fn = buf;
-  int absolute = 0;
+  char *fn = buf;
+  bool absolute = 0;
   ptrdiff_t want_length;
   Lisp_Object filename;
   struct stat st;
@@ -1503,7 +1498,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
         {
           ptrdiff_t fnlen, lsuffix = SBYTES (XCAR (tail));
           Lisp_Object handler;
-          int exists;
+          bool exists;
 
           /* Concatenate path element/specified name with the suffix.
              If the directory starts with /:, remove that.  */
@@ -1588,14 +1583,16 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
    the source has an associated file name or not.
 
    FILENAME is the file name that we are loading from.
-   ENTIRE is 1 if loading that entire file, 0 if evaluating part of it.  */
+
+   ENTIRE is true if loading that entire file, false if evaluating
+   part of it.  */
 
 static void
-build_load_history (Lisp_Object filename, int entire)
+build_load_history (Lisp_Object filename, bool entire)
 {
-  register Lisp_Object tail, prev, newelt;
-  register Lisp_Object tem, tem2;
-  register int foundit = 0;
+  Lisp_Object tail, prev, newelt;
+  Lisp_Object tem, tem2;
+  bool foundit = 0;
 
   tail = Vload_history;
   prev = Qnil;
@@ -1680,7 +1677,7 @@ static void
 readevalloop (Lisp_Object readcharfun,
               FILE *stream,
               Lisp_Object sourcename,
-              int printflag,
+              bool printflag,
               Lisp_Object unibyte, Lisp_Object readfun,
               Lisp_Object start, Lisp_Object end)
 {
@@ -1689,12 +1686,12 @@ readevalloop (Lisp_Object readcharfun,
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   struct buffer *b = 0;
-  int continue_reading_p;
+  bool continue_reading_p;
   Lisp_Object lex_bound;
-  /* Nonzero if reading an entire buffer.  */
-  int whole_buffer = 0;
-  /* 1 on the first time around.  */
-  int first_sexp = 1;
+  /* True if reading an entire buffer.  */
+  bool whole_buffer = 0;
+  /* True on the first time around.  */
+  bool first_sexp = 1;
   Lisp_Object macroexpand = intern ("internal-macroexpand-for-load");
 
   if (NILP (Ffboundp (macroexpand))
@@ -2072,9 +2069,9 @@ static char *read_buffer;
    If the escape sequence forces unibyte, return eight-bit char.  */
 
 static int
-read_escape (Lisp_Object readcharfun, int stringp)
+read_escape (Lisp_Object readcharfun, bool stringp)
 {
-  register int c = READCHAR;
+  int c = READCHAR;
   /* \u allows up to four hex digits, \U up to eight.  Default to the
      behavior for \u, and change this value in the case that \U is seen.  */
   int unicode_hex_count = 4;
@@ -2375,10 +2372,10 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
    in *PCH and the return value is not interesting.  Else, we store
    zero in *PCH and we read and return one lisp object.
 
-   FIRST_IN_LIST is nonzero if this is the first element of a list.  */
+   FIRST_IN_LIST is true if this is the first element of a list.  */
 
 static Lisp_Object
-read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
+read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 {
   int c;
   bool uninterned_symbol = 0;
@@ -2803,10 +2800,11 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
         else
           {
             Lisp_Object value;
+            bool saved_new_backquote_flag = new_backquote_flag;
 
-            new_backquote_flag++;
+            new_backquote_flag = 1;
             value = read0 (readcharfun);
-            new_backquote_flag--;
+            new_backquote_flag = saved_new_backquote_flag;
 
             return Fcons (Qbackquote, Fcons (value, Qnil));
           }
@@ -2858,7 +2856,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
       {
         int modifiers;
         int next_char;
-        int ok;
+        bool ok;
 
         c = READCHAR;
         if (c < 0)
@@ -2894,14 +2892,14 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
       {
         char *p = read_buffer;
         char *end = read_buffer + read_buffer_size;
-        register int ch;
-        /* Nonzero if we saw an escape sequence specifying
+        int ch;
+        /* True if we saw an escape sequence specifying
            a multibyte character.  */
-        int force_multibyte = 0;
-        /* Nonzero if we saw an escape sequence specifying
+        bool force_multibyte = 0;
+        /* True if we saw an escape sequence specifying
            a single-byte character.  */
-        int force_singlebyte = 0;
-        int cancel = 0;
+        bool force_singlebyte = 0;
+        bool cancel = 0;
         ptrdiff_t nchars = 0;
 
         while ((ch = READCHAR) >= 0
@@ -3033,7 +3031,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
     read_symbol:
       {
         char *p = read_buffer;
-        int quoted = 0;
+        bool quoted = 0;
         EMACS_INT start_position = readchar_count - 1;
 
         {
@@ -3250,17 +3248,17 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
 /* Convert STRING to a number, assuming base BASE.  Return a fixnum if CP has
    integer syntax and fits in a fixnum, else return the nearest float if CP has
    either floating point or integer syntax and BASE is 10, else return nil.  If
-   IGNORE_TRAILING is nonzero, consider just the longest prefix of CP that has
+   IGNORE_TRAILING, consider just the longest prefix of CP that has
    valid floating point syntax.  Signal an overflow if BASE is not 10 and the
    number has integer syntax but does not fit.  */
 
 Lisp_Object
-string_to_number (char const *string, int base, int ignore_trailing)
+string_to_number (char const *string, int base, bool ignore_trailing)
 {
   int state;
   char const *cp = string;
   int leading_digit;
-  int float_syntax = 0;
+  bool float_syntax = 0;
   double value = 0;
 
   /* Compute NaN and infinities using a variable, to cope with compilers that
@@ -3270,9 +3268,9 @@ string_to_number (char const *string, int base, int ignore_trailing)
   /* Negate the value ourselves.  This treats 0, NaNs, and infinity properly on
      IEEE floating point hosts, and works around a formerly-common bug where
      atof ("-0.0") drops the sign.  */
-  int negative = *cp == '-';
+  bool negative = *cp == '-';
 
-  int signedp = negative || *cp == '+';
+  bool signedp = negative || *cp == '+';
   cp += signedp;
 
   state = 0;
@@ -3365,7 +3363,7 @@ string_to_number (char const *string, int base, int ignore_trailing)
       uintmax_t n;
 
       /* Fast special case for single-digit integers.  This also avoids a
-         glitch when BASE is 16 and IGNORE_TRAILING is nonzero, because in that
+         glitch when BASE is 16 and IGNORE_TRAILING, because in that
          case some versions of strtoumax accept numbers like "0x1" that Emacs
          does not allow.  */
       if (digit_to_number (string[signedp + 1], base) < 0)
@@ -3401,12 +3399,12 @@ string_to_number (char const *string, int base, int ignore_trailing)
 
 
 static Lisp_Object
-read_vector (Lisp_Object readcharfun, int bytecodeflag)
+read_vector (Lisp_Object readcharfun, bool bytecodeflag)
 {
   ptrdiff_t i, size;
-  register Lisp_Object *ptr;
-  register Lisp_Object tem, item, vector;
-  register struct Lisp_Cons *otem;
+  Lisp_Object *ptr;
+  Lisp_Object tem, item, vector;
+  struct Lisp_Cons *otem;
   Lisp_Object len;
 
   tem = read_list (1, readcharfun);
@@ -3478,13 +3476,13 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
   return vector;
 }
 
-/* FLAG = 1 means check for ] to terminate rather than ) and .  */
+/* FLAG means check for ] to terminate rather than ) and .  */
 
 static Lisp_Object
-read_list (int flag, register Lisp_Object readcharfun)
+read_list (bool flag, Lisp_Object readcharfun)
 {
   Lisp_Object val, tail;
-  register Lisp_Object elt, tem;
+  Lisp_Object elt, tem;
   struct gcpro gcpro1, gcpro2;
   /* 0 is the normal case.
      1 means this list is a doc reference; replace it with the number 0.
@@ -3492,7 +3490,7 @@ read_list (int flag, register Lisp_Object readcharfun)
   int doc_reference = 0;
 
   /* Initialize this to 1 if we are reading a list.  */
-  int first_in_list = flag <= 0;
+  bool first_in_list = flag <= 0;
 
   val = Qnil;
   tail = Qnil;
diff --git a/src/macros.c b/src/macros.c
index a507f12e343..632c851ee8c 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -84,7 +84,7 @@ macro before appending to it. */)
     {
       ptrdiff_t i;
       EMACS_INT len;
-      int cvt;
+      bool cvt;
 
       /* Check the type of last-kbd-macro in case Lisp code changed it.  */
       CHECK_VECTOR_OR_STRING (KVAR (current_kboard, Vlast_kbd_macro));
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index f96f765a7fa..e4a77cc87a3 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -736,7 +736,6 @@ $(BLD)/dispnew.$(O) : \
         $(SRC)/disptab.h \
         $(SRC)/indent.h \
         $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
         $(NT_INC)/unistd.h \
         $(BUFFER_H) \
         $(CHARACTER_H) \
@@ -1016,7 +1015,6 @@ $(BLD)/indent.$(O) : \
         $(SRC)/indent.h \
         $(SRC)/region-cache.h \
         $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
         $(BUFFER_H) \
         $(CHARACTER_H) \
         $(CONFIG_H) \
@@ -1413,7 +1411,6 @@ $(BLD)/term.$(O) : \
         $(SRC)/disptab.h \
         $(SRC)/keymap.h \
         $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
         $(SRC)/tparam.h \
         $(NT_INC)/sys/file.h \
         $(NT_INC)/sys/time.h \
diff --git a/src/marker.c b/src/marker.c
index e01647bdb2a..69be4faec3a 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -29,7 +29,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static ptrdiff_t cached_charpos;
 static ptrdiff_t cached_bytepos;
 static struct buffer *cached_buffer;
-static int cached_modiff;
+static EMACS_INT cached_modiff;
 
 /* Juanma Barranquero <lekktu@gmail.com> reported ~3x increased
    bootstrap time when byte_char_debug_check is enabled; so this
@@ -91,7 +91,7 @@ clear_charpos_cache (struct buffer *b)
 #define CONSIDER(CHARPOS, BYTEPOS)                                      \
 {                                                                       \
   ptrdiff_t this_charpos = (CHARPOS);                                   \
-  int changed = 0;                                                      \
+  bool changed = 0;                                                     \
                                                                         \
   if (this_charpos == charpos)                                          \
     {                                                                   \
@@ -190,7 +190,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
 
   if (charpos - best_below < best_above - charpos)
     {
-      int record = charpos - best_below > 5000;
+      bool record = charpos - best_below > 5000;
 
       while (best_below != charpos)
         {
@@ -215,7 +215,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
     }
   else
     {
-      int record = best_above - charpos > 5000;
+      bool record = best_above - charpos > 5000;
 
       while (best_above != charpos)
         {
@@ -335,7 +335,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
 
   if (bytepos - best_below_byte < best_above_byte - bytepos)
     {
-      int record = bytepos - best_below_byte > 5000;
+      bool record = bytepos - best_below_byte > 5000;
 
       while (best_below_byte < bytepos)
         {
@@ -362,7 +362,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
     }
   else
     {
-      int record = best_above_byte - bytepos > 5000;
+      bool record = best_above_byte - bytepos > 5000;
 
       while (best_above_byte > bytepos)
         {
@@ -479,10 +479,10 @@ live_buffer (Lisp_Object buffer)
 
 static Lisp_Object
 set_marker_internal (Lisp_Object marker, Lisp_Object position,
-                     Lisp_Object buffer, int restricted)
+                     Lisp_Object buffer, bool restricted)
 {
-  register struct Lisp_Marker *m;
-  register struct buffer *b = live_buffer (buffer);
+  struct Lisp_Marker *m;
+  struct buffer *b = live_buffer (buffer);
 
   CHECK_MARKER (marker);
   m = XMARKER (marker);
diff --git a/src/menu.c b/src/menu.c
index 835267b2f0c..7cc110ce7e2 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -331,7 +331,7 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk
 {
   Lisp_Object map, item_string, enabled;
   struct gcpro gcpro1, gcpro2;
-  int res;
+  bool res;
   struct skp *skp = skp_v;
 
   /* Parse the menu item and leave the result in item_properties.  */
@@ -519,14 +519,15 @@ list_of_panes (Lisp_Object menu)
 /* Set up data in menu_items for a menu bar item
    whose event type is ITEM_KEY (with string ITEM_NAME)
    and whose contents come from the list of keymaps MAPS.  */
-int
-parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name, Lisp_Object maps)
+bool
+parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name,
+                      Lisp_Object maps)
 {
   Lisp_Object length;
   EMACS_INT len;
   Lisp_Object *mapvec;
   ptrdiff_t i;
-  int top_level_items = 0;
+  bool top_level_items = 0;
   USE_SAFE_ALLOCA;
 
   length = Flength (maps);
@@ -616,13 +617,13 @@ free_menubar_widget_value_tree (widget_value *wv)
    in menu_items starting at index START, up to index END.  */
 
 widget_value *
-digest_single_submenu (int start, int end, int top_level_items)
+digest_single_submenu (int start, int end, bool top_level_items)
 {
   widget_value *wv, *prev_wv, *save_wv, *first_wv;
   int i;
   int submenu_depth = 0;
   widget_value **submenu_stack;
-  int panes_seen = 0;
+  bool panes_seen = 0;
 
   submenu_stack = alloca (menu_items_used * sizeof *submenu_stack);
   wv = xmalloc_widget_value ();
@@ -668,7 +669,7 @@ digest_single_submenu (int start, int end, int top_level_items)
           Lisp_Object pane_name;
           const char *pane_string;
 
-          panes_seen++;
+          panes_seen = 1;
 
           pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
 
@@ -735,7 +736,7 @@ digest_single_submenu (int start, int end, int top_level_items)
           Lisp_Object help;
 
           /* All items should be contained in panes.  */
-          if (panes_seen == 0)
+          if (! panes_seen)
             emacs_abort ();
 
           item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
@@ -957,9 +958,9 @@ find_and_call_menu_selection (FRAME_PTR f, int menu_bar_items_used, Lisp_Object
 
 #ifdef HAVE_NS
 /* As above, but return the menu selection instead of storing in kb buffer.
-   If keymaps==1, return full prefixes to selection. */
+   If KEYMAPS, return full prefixes to selection. */
 Lisp_Object
-find_and_return_menu_selection (FRAME_PTR f, int keymaps, void *client_data)
+find_and_return_menu_selection (FRAME_PTR f, bool keymaps, void *client_data)
 {
   Lisp_Object prefix, entry;
   int i;
@@ -999,7 +1000,7 @@ find_and_return_menu_selection (FRAME_PTR f, int keymaps, void *client_data)
             = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
           if (aref_addr (menu_items, i) == client_data)
             {
-              if (keymaps != 0)
+              if (keymaps)
                 {
                   int j;
 
@@ -1071,8 +1072,8 @@ no quit occurs and `x-popup-menu' returns nil.  */)
   Lisp_Object selection = Qnil;
   FRAME_PTR f = NULL;
   Lisp_Object x, y, window;
-  int keymaps = 0;
-  int for_click = 0;
+  bool keymaps = 0;
+  bool for_click = 0;
   ptrdiff_t specpdl_count = SPECPDL_INDEX ();
   struct gcpro gcpro1;
 
@@ -1083,7 +1084,7 @@ no quit occurs and `x-popup-menu' returns nil.  */)
 
 #ifdef HAVE_MENUS
   {
-    int get_current_pos_p = 0;
+    bool get_current_pos_p = 0;
     /* FIXME!!  check_w32 (); or check_x (); or check_ns (); */
 
     /* Decode the first argument: find the window and the coordinates.  */
diff --git a/src/menu.h b/src/menu.h
index 3406928a8d5..67934c42d76 100644
--- a/src/menu.h
+++ b/src/menu.h
@@ -29,7 +29,7 @@ extern void init_menu_items (void);
 extern void finish_menu_items (void) ATTRIBUTE_CONST;
 extern void discard_menu_items (void);
 extern void save_menu_items (void);
-extern int parse_single_submenu (Lisp_Object, Lisp_Object, Lisp_Object);
+extern bool parse_single_submenu (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void list_of_panes (Lisp_Object);
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI) \
   || defined (HAVE_NS)
@@ -38,7 +38,7 @@ extern void update_submenu_strings (widget_value *);
 extern void find_and_call_menu_selection (FRAME_PTR, int,
                                           Lisp_Object, void *);
 extern widget_value *xmalloc_widget_value (void);
-extern widget_value *digest_single_submenu (int, int, int);
+extern widget_value *digest_single_submenu (int, int, bool);
 #endif
 
 #ifdef HAVE_X_WINDOWS
@@ -47,8 +47,8 @@ extern void mouse_position_for_popup (FRAME_PTR f, int *x, int *y);
 
 extern Lisp_Object w32_menu_show (FRAME_PTR, int, int, int, int,
                                   Lisp_Object, const char **);
-extern Lisp_Object ns_menu_show (FRAME_PTR, int, int, int, int,
+extern Lisp_Object ns_menu_show (FRAME_PTR, int, int, bool, bool,
                                  Lisp_Object, const char **);
-extern Lisp_Object xmenu_show (FRAME_PTR, int, int, int, int,
+extern Lisp_Object xmenu_show (FRAME_PTR, int, int, bool, bool,
                                Lisp_Object, const char **, Time);
 #endif /* MENU_H */
diff --git a/src/minibuf.c b/src/minibuf.c
index dd4ca34c3fb..2cc89e75680 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -173,17 +173,6 @@ without invoking the usual minibuffer commands.  */)
 
 static Lisp_Object read_minibuf_unwind (Lisp_Object);
 static Lisp_Object run_exit_minibuf_hook (Lisp_Object);
-static Lisp_Object read_minibuf (Lisp_Object, Lisp_Object,
-                                 Lisp_Object,
-                                 int, Lisp_Object,
-                                 Lisp_Object, Lisp_Object,
-                                 int, int);
-static Lisp_Object read_minibuf_noninteractive (Lisp_Object, Lisp_Object,
-                                                Lisp_Object, Lisp_Object,
-                                                int, Lisp_Object,
-                                                Lisp_Object, Lisp_Object,
-                                                int, int);
-static Lisp_Object string_to_object (Lisp_Object, Lisp_Object);
 
 
 /* Read a Lisp object from VAL and return it.  If VAL is an empty
@@ -233,10 +222,10 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
 static Lisp_Object
 read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
                              Lisp_Object prompt, Lisp_Object backup_n,
-                             int expflag,
+                             bool expflag,
                              Lisp_Object histvar, Lisp_Object histpos,
                              Lisp_Object defalt,
-                             int allow_props, int inherit_input_method)
+                             bool allow_props, bool inherit_input_method)
 {
   ptrdiff_t size, len;
   char *line;
@@ -376,23 +365,23 @@ If the current buffer is not a minibuffer, return its entire contents.  */)
    beginning of INITIAL if N <= 0.
 
    Normally return the result as a string (the text that was read),
-   but if EXPFLAG is nonzero, read it and return the object read.
+   but if EXPFLAG, read it and return the object read.
    If HISTVAR is given, save the value read on that history only if it doesn't
    match the front of that history list exactly.  The value is pushed onto
    the list as the string that was read.
 
    DEFALT specifies the default value for the sake of history commands.
 
-   If ALLOW_PROPS is nonzero, we do not throw away text properties.
+   If ALLOW_PROPS, do not throw away text properties.
 
-   if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
+   if INHERIT_INPUT_METHOD, the minibuffer inherits the
    current input method.  */
 
 static Lisp_Object
 read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
-              int expflag,
+              bool expflag,
               Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
-              int allow_props, int inherit_input_method)
+              bool allow_props, bool inherit_input_method)
 {
   Lisp_Object val;
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -1447,7 +1436,7 @@ is used to further constrain the set of candidates.  */)
               if (bestmatchsize != SCHARS (eltstring)
                   || bestmatchsize != matchsize)
                 /* Don't count the same string multiple times.  */
-                matchcount++;
+                matchcount += matchcount <= 1;
               bestmatchsize = matchsize;
               if (matchsize <= SCHARS (string)
                   /* If completion-ignore-case is non-nil, don't
diff --git a/src/nsfont.m b/src/nsfont.m
index 20a8f5d4028..a820b60ac58 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -53,8 +53,6 @@ extern float ns_antialias_threshold;
 extern int ns_tmp_flags;
 extern struct nsfont_info *ns_tmp_font;
 
-static Lisp_Object Vfonts_in_cache;
-
 
 /* font glyph and metrics caching functions, implemented at end */
 static void ns_uni_to_glyphs (struct nsfont_info *font_info,
@@ -815,7 +813,6 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
                                   numberWithUnsignedLongLong:
                                     (unsigned long long) XHASH (font_object)]
                         forKey: nsfont];
-          Vfonts_in_cache = Fcons (font_object, Vfonts_in_cache);
         }
     }
 
@@ -1535,7 +1532,4 @@ syms_of_nsfont (void)
                doc: /* Internal use: maps font registry to Unicode script. */);
 
   ascii_printable = NULL;
-
-  Vfonts_in_cache = Qnil;
-  staticpro (&Vfonts_in_cache);
 }
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 9af732c6c45..d0ea8f5a47a 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -128,8 +128,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
   static EmacsMenu *last_submenu = nil;
   BOOL needsSet = NO;
   const char *submenuTitle = [[submenu title] UTF8String];
-  extern int waiting_for_input;
-  int owfi;
+  bool owfi;
   Lisp_Object items;
   widget_value *wv, *first_wv, *prev_wv = 0;
   int i;
@@ -182,7 +181,8 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
       /* Fully parse one or more of the submenus. */
       int n = 0;
       int *submenu_start, *submenu_end;
-      int *submenu_top_level_items, *submenu_n_panes;
+      bool *submenu_top_level_items;
+      int *submenu_n_panes;
       struct buffer *prev = current_buffer;
       Lisp_Object buffer;
       ptrdiff_t specpdl_count = SPECPDL_INDEX ();
@@ -741,7 +741,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 
 /* run a menu in popup mode */
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
-                 keymaps: (int)keymaps
+                 keymaps: (bool)keymaps
 {
   EmacsView *view = FRAME_NS_VIEW (f);
   NSEvent *e, *event;
@@ -780,7 +780,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
    ========================================================================== */
 
 Lisp_Object
-ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+ns_menu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
               Lisp_Object title, const char **error)
 {
   EmacsMenu *pmenu;
@@ -802,7 +802,7 @@ ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
 
 #if 0
   /* FIXME: a couple of one-line differences prevent reuse */
-  wv = digest_single_submenu (0, menu_items_used, Qnil);
+  wv = digest_single_submenu (0, menu_items_used, 0);
 #else
   {
   widget_value *save_wv = 0, *prev_wv = 0;
diff --git a/src/nsterm.h b/src/nsterm.h
index 958d1ce7853..2e868b86caf 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -161,7 +161,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (EmacsMenu *)addSubmenuWithTitle: (const char *)title forFrame: (struct frame *)f;
 - (void) clear;
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
-                 keymaps: (int)keymaps;
+                 keymaps: (bool)keymaps;
 @end
 
 
@@ -792,7 +792,7 @@ extern void free_frame_tool_bar (FRAME_PTR f);
 extern void find_and_call_menu_selection (FRAME_PTR f,
     int menu_bar_items_used, Lisp_Object vector, void *client_data);
 extern Lisp_Object find_and_return_menu_selection (FRAME_PTR f,
-                                                   int keymaps,
+                                                   bool keymaps,
                                                    void *client_data);
 extern Lisp_Object ns_popup_dialog (Lisp_Object position, Lisp_Object contents,
                                     Lisp_Object header);
diff --git a/src/nsterm.m b/src/nsterm.m
index 6b739befeeb..1d935fc76de 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -55,7 +55,6 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include "ccl.h"
 
 #include "termhooks.h"
-#include "termopts.h"
 #include "termchar.h"
 
 #include "window.h"
@@ -1315,7 +1314,7 @@ static void
 ns_fullscreen_hook (FRAME_PTR f)
 {
   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
-  
+
   if (! f->async_visible) return;
 #ifndef NEW_STYLE_FS
   if (f->want_fullscreen == FULLSCREEN_BOTH)
@@ -5942,7 +5941,7 @@ not_in_argv (NSString *arg)
       [w setBackgroundColor: col];
       if ([col alphaComponent] != 1.0)
         [w setOpaque: NO];
-      
+
       f->border_width = bwidth;
       FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
       FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
@@ -5995,7 +5994,7 @@ not_in_argv (NSString *arg)
             }
           break;
         }
-  
+
       emacsframe->want_fullscreen = FULLSCREEN_NONE;
     }
 
diff --git a/src/process.c b/src/process.c
index c941a196539..2cbce9d28ea 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4302,7 +4302,7 @@ wait_reading_process_output_1 (void)
      -1 meaning caller will actually read the input, so don't throw to
        the quit handler, or
 
-   DO_DISPLAY != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
      output that arrives.
 
    If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
@@ -4322,7 +4322,7 @@ wait_reading_process_output_1 (void)
 
 int
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
-                             int do_display,
+                             bool do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
@@ -4419,7 +4419,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
           do
             {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
               struct buffer *old_buffer = current_buffer;
               Lisp_Object old_window = selected_window;
 
@@ -4753,7 +4753,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
       if (read_kbd != 0)
         {
-          int old_timers_run = timers_run;
+          unsigned old_timers_run = timers_run;
           struct buffer *old_buffer = current_buffer;
           Lisp_Object old_window = selected_window;
           int leave = 0;
@@ -6821,14 +6821,14 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
    see full version for other parameters. We know that wait_proc will
      always be NULL, since `subprocesses' isn't defined.
 
-   DO_DISPLAY != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
    output that arrives.
 
    Return true if we received input from any process.  */
 
 int
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
-                             int do_display,
+                             bool do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
@@ -6904,7 +6904,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
           do
             {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
               timer_delay = timer_check ();
               if (timers_run != old_timers_run && do_display)
                 /* We must retry, since a timer may have requeued itself
diff --git a/src/regex.c b/src/regex.c
index 17562043df1..7443eff3977 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1834,7 +1834,6 @@ typedef struct
 /* Explicit quit checking is needed for Emacs, which uses polling to
    process input events.  */
 #ifdef emacs
-extern int immediate_quit;
 # define IMMEDIATE_QUIT_CHECK                   \
     do {                                        \
       if (immediate_quit) QUIT;                 \
diff --git a/src/search.c b/src/search.c
index 7c084c62e28..aacdbe33eef 100644
--- a/src/search.c
+++ b/src/search.c
@@ -636,12 +636,12 @@ newline_cache_on_off (struct buffer *buf)
    If we don't find COUNT instances before reaching END, set *SHORTAGE
    to the number of TARGETs left unfound, and return END.
 
-   If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
+   If ALLOW_QUIT, set immediate_quit.  That's good to do
    except when inside redisplay.  */
 
 ptrdiff_t
-scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
-             ptrdiff_t count, ptrdiff_t *shortage, int allow_quit)
+scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
+             ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
 {
   struct region_cache *newline_cache;
   int direction;
@@ -837,23 +837,23 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
    the number of line boundaries left unfound, and position at
    the limit we bumped up against.
 
-   If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
+   If ALLOW_QUIT, set immediate_quit.  That's good to do
    except in special cases.  */
 
 EMACS_INT
 scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
               ptrdiff_t limit, ptrdiff_t limit_byte,
-              register EMACS_INT count, int allow_quit)
+              EMACS_INT count, bool allow_quit)
 {
   int direction = ((count > 0) ? 1 : -1);
 
-  register unsigned char *cursor;
+  unsigned char *cursor;
   unsigned char *base;
 
   ptrdiff_t ceiling;
-  register unsigned char *ceiling_addr;
+  unsigned char *ceiling_addr;
 
-  int old_immediate_quit = immediate_quit;
+  bool old_immediate_quit = immediate_quit;
 
   /* The code that follows is like scan_buffer
      but checks for either newline or carriage return.  */
diff --git a/src/term.c b/src/term.c
index 189fb783cbc..acce9c0548c 100644
--- a/src/term.c
+++ b/src/term.c
@@ -28,7 +28,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "lisp.h"
 #include "termchar.h"
-#include "termopts.h"
 #include "tparam.h"
 #include "character.h"
 #include "buffer.h"
diff --git a/src/termopts.h b/src/termopts.h
index 7bf71aeefe7..05fa0a52eee 100644
--- a/src/termopts.h
+++ b/src/termopts.h
@@ -17,15 +17,8 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
-/* Nonzero means use ^S/^Q as cretinous flow control.  */
-extern int flow_control;
-
 /* Nonzero means use interrupt-driven input.  */
-extern int interrupt_input;
+extern bool interrupt_input;
 
 /* Nonzero while interrupts are temporarily deferred during redisplay.  */
-extern int interrupts_deferred;
-
-/* Terminal has meta key */
-extern int meta_key;
-
+extern bool interrupts_deferred;
diff --git a/src/w32select.c b/src/w32select.c
index ee0e6d16b11..1b10c74cfe9 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -76,6 +76,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "w32term.h"    /* for all of the w32 includes */
 #include "w32common.h"  /* os_subtype */
+#include "keyboard.h"
 #include "blockinput.h"
 #include "charset.h"
 #include "coding.h"
@@ -393,7 +394,6 @@ run_protected (Lisp_Object (*code) (Lisp_Object), Lisp_Object arg)
      with global variables and calling strange looking functions.  Is
      this really the right way to run Lisp callbacks?  */
 
-  extern int waiting_for_input; /* from keyboard.c */
   int owfi;
 
   block_input ();
diff --git a/src/xmenu.c b/src/xmenu.c
index 96a1ae87fdc..01d932cf8d8 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -111,7 +111,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static Lisp_Object Qdebug_on_next_call;
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
-static Lisp_Object xdialog_show (FRAME_PTR, int, Lisp_Object, Lisp_Object,
+static Lisp_Object xdialog_show (FRAME_PTR, bool, Lisp_Object, Lisp_Object,
                                  const char **);
 #endif
 
@@ -930,7 +930,8 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
   widget_value *wv, *first_wv, *prev_wv = 0;
   int i;
   int *submenu_start, *submenu_end;
-  int *submenu_top_level_items, *submenu_n_panes;
+  bool *submenu_top_level_items;
+  int *submenu_n_panes;
 
   if (! FRAME_X_P (f))
     emacs_abort ();
@@ -1346,8 +1347,8 @@ free_frame_menubar (FRAME_PTR f)
 /* F is the frame the menu is for.
    X and Y are the frame-relative specified position,
    relative to the inside upper left corner of the frame F.
-   FOR_CLICK is nonzero if this menu was invoked for a mouse click.
-   KEYMAPS is 1 if this menu was specified with keymaps;
+   FOR_CLICK is true if this menu was invoked for a mouse click.
+   KEYMAPS is true if this menu was specified with keymaps;
     in that case, we return a list containing the chosen item's value
     and perhaps also the pane's prefix.
    TITLE is the specified menu title.
@@ -1427,14 +1428,14 @@ pop_down_menu (Lisp_Object arg)
    menu_item_selection will be set to the selection.  */
 static void
 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv, int x, int y,
-                            int for_click, Time timestamp)
+                            bool for_click, Time timestamp)
 {
   int i;
   GtkWidget *menu;
   GtkMenuPositionFunc pos_func = 0;  /* Pop up at pointer.  */
   struct next_popup_x_y popup_x_y;
   ptrdiff_t specpdl_count = SPECPDL_INDEX ();
-  int use_pos_func = ! for_click;
+  bool use_pos_func = ! for_click;
 
 #ifdef HAVE_GTK3
   /* Always use position function for Gtk3.  Otherwise menus may become
@@ -1539,7 +1540,7 @@ pop_down_menu (Lisp_Object arg)
    menu_item_selection will be set to the selection.  */
 static void
 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
-                            int x, int y, int for_click, Time timestamp)
+                            int x, int y, bool for_click, Time timestamp)
 {
   int i;
   Arg av[2];
@@ -1623,7 +1624,7 @@ cleanup_widget_value_tree (Lisp_Object arg)
 }
 
 Lisp_Object
-xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
             Lisp_Object title, const char **error_name, Time timestamp)
 {
   int i;
@@ -1878,7 +1879,7 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
                 = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
               if (menu_item_selection == aref_addr (menu_items, i))
                 {
-                  if (keymaps != 0)
+                  if (keymaps)
                     {
                       int j;
 
@@ -2011,7 +2012,7 @@ static const char * button_names [] = {
 
 static Lisp_Object
 xdialog_show (FRAME_PTR f,
-              int keymaps,
+              bool keymaps,
               Lisp_Object title,
               Lisp_Object header,
               const char **error_name)
@@ -2277,7 +2278,7 @@ pop_down_menu (Lisp_Object arg)
 
 
 Lisp_Object
-xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
             Lisp_Object title, const char **error_name, Time timestamp)
 {
   Window root;
@@ -2528,7 +2529,7 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
                     {
                       entry
                         = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
-                      if (keymaps != 0)
+                      if (keymaps)
                         {
                           entry = Fcons (entry, Qnil);
                           if (!NILP (pane_prefix))
diff --git a/src/xsettings.c b/src/xsettings.c
index 7c68ff295cf..d23070791d8 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -29,7 +29,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "blockinput.h"
 #include "termhooks.h"
-#include "termopts.h"
 
 #include <X11/Xproto.h>
 
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 8067899f931..289aac8492b 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -35,7 +35,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "sysselect.h"
 #include "frame.h"
 #include "termhooks.h"
-#include "termopts.h"
 #include "xterm.h"
 #include "process.h"
 #include "keyboard.h"