Merge from origin/emacs-26

2fcf2df Fix copyright years by hand
26bed8b Update copyright year to 2019
2814292 Fix value of default frame height.  (Bug#33921)

diff --cc .gitignore
Simple merge

diff --cc ChangeLog.2
Simple merge

diff --cc Makefile.in
Simple merge

diff --cc README
Simple merge

diff --cc admin/admin.el
Simple merge

diff --cc admin/find-gc.el
Simple merge

diff --cc admin/gitmerge.el
Simple merge

diff --cc admin/grammars/make.by
Simple merge

diff --cc admin/grammars/scheme.by
Simple merge

diff --cc admin/merge-gnulib
Simple merge

diff --cc admin/notes/multi-tty
Simple merge

diff --cc admin/notes/unicode
Simple merge

diff --cc admin/nt/dist-build/build-dep-zips.py
Simple merge

diff --cc admin/nt/dist-build/build-zips.sh
Simple merge

diff --cc admin/unidata/unidata-gen.el
Simple merge

diff --cc admin/unidata/uvs.el
Simple merge

diff --cc admin/update_autogen
Simple merge

diff --cc autogen.sh
Simple merge

diff --cc build-aux/config.guess
index 28bec27b3079308ec442a2b93e5544a11861d969,5dacc2912368513ef1820d3c390e52a3f30252e9..3ea87fbf0b76fb348991185402239781d2e7d022
--- 1/build-aux/config.guess
--- 2/build-aux/config.guess
+++ b/build-aux/config.guess
@@@ -1,8 -1,8 +1,8 @@@
  #! /bin/sh
  # Attempt to guess a canonical system name.
- #   Copyright 1992-2018 Free Software Foundation, Inc.
+ #   Copyright 1992-2019 Free Software Foundation, Inc.
  
 -timestamp='2018-01-01'
 +timestamp='2018-12-07'
  
  # This file is free software; you can redistribute it and/or modify it
  # under the terms of the GNU General Public License as published by

diff --cc build-aux/config.sub
index a5081b8e0d1d3dff5c9a9fb1accf757c0c72cd90,cb90ee490998ab3bca02285f35c3d3f1dc508a77..872516579f2264d8208de6ffec3cc384600f4c5a
--- 1/build-aux/config.sub
--- 2/build-aux/config.sub
+++ b/build-aux/config.sub
@@@ -1,8 -1,8 +1,8 @@@
  #! /bin/sh
  # Configuration validation subroutine script.
- #   Copyright 1992-2018 Free Software Foundation, Inc.
+ #   Copyright 1992-2019 Free Software Foundation, Inc.
  
 -timestamp='2018-01-01'
 +timestamp='2018-12-16'
  
  # This file is free software; you can redistribute it and/or modify it
  # under the terms of the GNU General Public License as published by

diff --cc build-aux/gitlog-to-changelog
Simple merge

diff --cc build-aux/move-if-change
Simple merge

diff --cc build-aux/update-copyright
index f2fc97e368f05f062e2616fb3c7d6e2f6a4cd732,19d881316afa92f4a0608bcce23dc7434e7664c6..d80549ea8dd3b3bf4dd65263c845426af294480b
--- 1/build-aux/update-copyright
--- 2/build-aux/update-copyright
+++ b/build-aux/update-copyright
@@@ -3,9 -3,9 +3,9 @@@ eval '(exit $?0)' && eval 'exec perl -w
      if 0;
  # Update an FSF copyright year list to include the current year.
  
 -my $VERSION = '2018-01-04.14:48'; # UTC
 +my $VERSION = '2018-03-07.03:47'; # UTC
  
- # Copyright (C) 2009-2018 Free Software Foundation, Inc.
+ # Copyright (C) 2009-2019 Free Software Foundation, Inc.
  #
  # This program is free software: you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by

diff --cc configure.ac
Simple merge

diff --cc doc/emacs/ChangeLog.1
Simple merge

diff --cc doc/emacs/Makefile.in
Simple merge

diff --cc doc/emacs/building.texi
Simple merge

diff --cc doc/emacs/cmdargs.texi
Simple merge

diff --cc doc/emacs/custom.texi
Simple merge

diff --cc doc/emacs/dired.texi
Simple merge

diff --cc doc/emacs/display.texi
Simple merge

diff --cc doc/emacs/emacs.texi
Simple merge

diff --cc doc/emacs/files.texi
Simple merge

diff --cc doc/emacs/fixit.texi
Simple merge

diff --cc doc/emacs/help.texi
Simple merge

diff --cc doc/emacs/maintaining.texi
Simple merge

diff --cc doc/emacs/mini.texi
Simple merge

diff --cc doc/emacs/misc.texi
Simple merge

diff --cc doc/emacs/msdos.texi
Simple merge

diff --cc doc/emacs/package.texi
Simple merge

diff --cc doc/emacs/programs.texi
Simple merge

diff --cc doc/emacs/regs.texi
Simple merge

diff --cc doc/emacs/rmail.texi
Simple merge

diff --cc doc/emacs/search.texi
Simple merge

diff --cc doc/emacs/sending.texi
Simple merge

diff --cc doc/emacs/text.texi
Simple merge

diff --cc doc/emacs/windows.texi
Simple merge

diff --cc doc/lispintro/Makefile.in
Simple merge

diff --cc doc/lispintro/emacs-lisp-intro.texi
Simple merge

diff --cc doc/lispref/Makefile.in
Simple merge

diff --cc doc/lispref/abbrevs.texi
Simple merge

diff --cc doc/lispref/buffers.texi
Simple merge

diff --cc doc/lispref/control.texi
Simple merge

diff --cc doc/lispref/debugging.texi
Simple merge

diff --cc doc/lispref/display.texi
Simple merge

diff --cc doc/lispref/edebug.texi
Simple merge

diff --cc doc/lispref/elisp.texi
Simple merge

diff --cc doc/lispref/errors.texi
Simple merge

diff --cc doc/lispref/eval.texi
Simple merge

diff --cc doc/lispref/files.texi
Simple merge

diff --cc doc/lispref/frames.texi
Simple merge

diff --cc doc/lispref/functions.texi
Simple merge

diff --cc doc/lispref/hash.texi
Simple merge

diff --cc doc/lispref/hooks.texi
Simple merge

diff --cc doc/lispref/internals.texi
Simple merge

diff --cc doc/lispref/intro.texi
Simple merge

diff --cc doc/lispref/keymaps.texi
Simple merge

diff --cc doc/lispref/lists.texi
Simple merge

diff --cc doc/lispref/loading.texi
Simple merge

diff --cc doc/lispref/minibuf.texi
Simple merge

diff --cc doc/lispref/modes.texi
Simple merge

diff --cc doc/lispref/nonascii.texi
Simple merge

diff --cc doc/lispref/numbers.texi
Simple merge

diff --cc doc/lispref/objects.texi
Simple merge

diff --cc doc/lispref/os.texi
Simple merge

diff --cc doc/lispref/package.texi
Simple merge

diff --cc doc/lispref/processes.texi
Simple merge

diff --cc doc/lispref/searching.texi
Simple merge

diff --cc doc/lispref/sequences.texi
Simple merge

diff --cc doc/lispref/streams.texi
Simple merge

diff --cc doc/lispref/strings.texi
Simple merge

diff --cc doc/lispref/syntax.texi
Simple merge

diff --cc doc/lispref/text.texi
Simple merge

diff --cc doc/lispref/threads.texi
Simple merge

diff --cc doc/lispref/windows.texi
Simple merge

diff --cc doc/man/etags.1
Simple merge

diff --cc doc/misc/Makefile.in
Simple merge

diff --cc doc/misc/auth.texi
Simple merge

diff --cc doc/misc/calc.texi
Simple merge

diff --cc doc/misc/cl.texi
Simple merge

diff --cc doc/misc/dired-x.texi
Simple merge

diff --cc doc/misc/ede.texi
Simple merge

diff --cc doc/misc/ediff.texi
Simple merge

diff --cc doc/misc/efaq.texi
Simple merge

diff --cc doc/misc/emacs-mime.texi
Simple merge

diff --cc doc/misc/ert.texi
Simple merge

diff --cc doc/misc/eshell.texi
Simple merge

diff --cc doc/misc/eww.texi
Simple merge

diff --cc doc/misc/flymake.texi
Simple merge

diff --cc doc/misc/gnus-faq.texi
Simple merge

diff --cc doc/misc/gnus.texi
Simple merge

diff --cc doc/misc/message.texi
Simple merge

diff --cc doc/misc/mh-e.texi
Simple merge

diff --cc doc/misc/org.texi
Simple merge

diff --cc doc/misc/tramp.texi
index 49c684f5bc9aeed9ad1f784846d9957feda23530,bfb6d748f242580b8c803352d3004bbd29e0d821..7587059f3934900b39bb23c4bab6e2ccda72f289
--- 1/doc/misc/tramp.texi
--- 2/doc/misc/tramp.texi
+++ b/doc/misc/tramp.texi
@@@ -12,8 -12,18 +12,8 @@@
  @c This is *so* much nicer :)
  @footnotestyle end
  
 -@c Macro for formatting a file name according to the respective
 -@c syntax.  Macro arguments should not have any leading or trailing
 -@c whitespace.  Not very elegant, but I don't know it better.
 -
 -@macro trampfn {method, userhost, localname}
 -@value{prefix}@c
 -\method\@value{postfixhop}@c
 -\userhost\@value{postfix}\localname\
 -@end macro
 -
  @copying
- Copyright @copyright{} 1999--2018 Free Software Foundation, Inc.
+ Copyright @copyright{} 1999--2019 Free Software Foundation, Inc.
  
  @quotation
  Permission is granted to copy, distribute and/or modify this document

diff --cc doc/misc/trampver.texi
index af7b6786a6a5712fadc4de8bd283e86045bc0d8b,aecbbe261c8fec5e776e48f761d3324bd22af4ff..f5cc2bae179271fc1aa5d70de9c128fdc545b95b
--- 1/doc/misc/trampver.texi
--- 2/doc/misc/trampver.texi
+++ b/doc/misc/trampver.texi
@@@ -2,15 -2,15 +2,15 @@@
  @c texi/trampver.texi.  Generated from trampver.texi.in by configure.
  
  @c This is part of the Emacs manual.
- @c Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ @c Copyright (C) 2003-2019 Free Software Foundation, Inc.
  @c See file doclicense.texi for copying conditions.
  
 -@c In the Tramp GIT, the version number is auto-frobbed from
 -@c configure.ac, so you should edit that file and run
 -@c "autoconf && ./configure" to change the version number.
 -@set trampver 2.3.4.26.2
 +@c In the Tramp GIT, the version number is auto-frobbed from tramp.el,
 +@c and the bug report address is auto-frobbed from configure.ac.
 +@set trampver 2.4.1
 +@set tramp-bug-report-address tramp-devel@@gnu.org
  
 -@c Other flags from configuration
 +@c Other flags from configuration.
  @set instprefix /usr/local
  @set lispdir /usr/local/share/emacs/site-lisp
  @set infodir /usr/local/share/info

diff --cc doc/misc/url.texi
Simple merge

diff --cc etc/DEBUG
Simple merge

diff --cc etc/HELLO
index 5b14bbbd75409289b23472ace38718a8e644fcac,ae52e94b06531588ded9eaeca1ac67ff6afd52bd..a56a73bc1d2587ee48970dbb8c05c202563e9523
--- 1/etc/HELLO
--- 2/etc/HELLO
+++ b/etc/HELLO
@@@ -22,88 -17,68 +22,88 @@@ Non-ASCII examples
  
  LANGUAGE (NATIVE NAME)        HELLO
  ----------------------        -----
 -Amharic (\e$,1O M[MmN{\e(B)     \e$,1M`MKM]\e(B
 -Arabic (\e$,1-g.$-y-q-h.*.1-i\e(B)      \e$,1-g.$-s.1.$-g.%\e(B \e$,1-y.$.*.#.%\e(B
 -Armenian (\e$,1+p+a+u+e, +e+v\e(B)      \e$,1+2+a, ,'\e(B \e$,1+q+e+f\e(B
 -Bengali (\e$,17,7>6b727>\e(B)   \e$,17(7.787M6u7>70\e(B
 -Braille       \e$,2(3(1('('(5\e(B
 -Burmese (\e$,1H9H\H4HZH9HL\e(B) \e$,1H9H$HZHYH"H<HLH5HK\e(B
 -C     printf ("Hello, world!\n");
 -Czech (\e,Bh\e(Be\e,B9\e(Btina)   Dobr\e,A}\e(B den
 -Danish (dansk)        Hej / Goddag / Hall\e,Ax\e(Bj
 +<x-charset><param>mule-unicode-0100-24ff</param>Amharic (አማርኛ)        ሠላም
 +Arabic (العربيّة)     السّلام عليكم
 +Armenian (հայերեն)     Բարև ձեզ
 +Bengali (বাংলা)     নমস্কার
 +</x-charset><x-charset><param>mule-unicode-2500-33ff</param>Braille   ⠓⠑⠇⠇⠕
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Burmese (မြန်မာ)      မင်္ဂလာပါ
 +</x-charset>C printf ("Hello, world!\n");
 +<x-charset><param>unicode</param>Cherokee (ᏣᎳᎩ ᎦᏬᏂᎯᏍᏗ)      ᎣᏏᏲ / ᏏᏲ
 +Comanche /kəˈmæntʃiː/    Haa marʉ́awe
 +
 +Cree (ᓀᐦᐃᔭᐍᐏᐣ)  ᑕᓂᓯ / ᐙᒋᔮ
 +
 +</x-charset><x-charset><param>latin-iso8859-2</param>Czech (čeština)        Dobrý den
 +</x-charset><x-charset><param>latin-iso8859-1</param>Danish (dansk)   Hej / Goddag / Halløj
  Dutch (Nederlands)    Hallo / Dag
 +</x-charset><x-charset><param>unicode</param>Efik  /ˈɛfɪk/ Mɔkɔm
 +
  Emacs emacs --no-splash -f view-hello-file
 -English /\e$(O+S\e,0!\e,D?\e$(O*y\e(Bl\e,0!\e$(O*h\e(B/       Hello
 -Esperanto     Saluton (E\e,C6\e(Bo\e,C~\e(Ban\e,Cx\e(Bo \e,Cf\e(Biu\e,C<\e(Ba\e,C}\e(Bde)
 -Estonian (eesti keel) Tere p\e,Ad\e(Bevast / Tere \e,Au\e(Bhtust
 -Finnish (suomi)       Hei / Hyv\e,Add\e(B p\e,Ad\e(Biv\e,Add\e(B
 -French (fran\e,Ag\e(Bais)       Bonjour / Salut
 -Georgian (\e$,1JEJ0J@J7J5J4J:J8\e(B)    \e$,1J2J0J;J0J@JOJ=J1J0\e(B
 -German (Deutsch)      Guten Tag / Gr\e,A|_\e(B Gott
 -Greek (\e,Fekkgmij\\e(B)        \e,FCei\\e(B \e,Fsar\e(B
 -Greek, ancient (\e$,1p1\e,Fkkgmij^\e(B)  \e,FO\e$,1pv\e,Fk]\e(B \e,Fte\e(B \e,Fja\e$,1q6\e(B \e,Fl]ca\e(B \e,Fwa\e$,1r6\e,Fqe\e(B
 -Gujarati (\e$,19W:!9\9p9~9d: \e(B)      \e$,19h9n9x:-9d:'\e(B
 -Hebrew (\e$,1-",q-(,y-*\e(B)    \e,Hylem\e(B
 -Hungarian (magyar)    Sz\e,Bi\e(Bp j\e,Bs\e(B napot!
 -Hindi (\e$,15y5\7f5B5f6 \e(B)     \e$,15h5n5x6-5d6'\e(B / \e$,15h5n5x6-5U5~5p\e(B \e$,16D\e(B
 -Italian (italiano)    Ciao / Buon giorno
 -Javanese (Jawa)       System.out.println("Sugeng siang!");
 -Kannada (\e$,1>u?(?M?(?!\e(B)   \e$,1?(?.?8?M>u?>?0\e(B
 -Khmer (\e$,1\7\V\?\V\!\r\8\b\:\e(B)     \e$,1\'\f\:\V\4\?\]\:\e(B
 -Lao (\e(1>RJRERG\e(B)   \e(1JP:R-4U\e(B / \e(1"mcKib*!4U\e(B
 -Malayalam (\e$,1@N@R@O@^@S@"\e(B)       \e$,1@H@N@X@m@5@^@P@"\e(B
 -Maltese (il-Malti)    Bon\e,Cu\e(Bu / Sa\e,C11\e(Ba
 -Mathematics   \e$,1x \e(B p \e$,1x(\e(B world \e$,1s"\e(B hello p  \e$,2!a\e(B
 -Mongolian (\e,L\^]S^[\e(B \e,Lem[\e(B)    \e,LAPY]\e(B \e,LQPY]P\e(B \e,Lcc\e(B?
 -Norwegian (norsk)     Hei / God dag
 -Oriya (\e$,1:s;\;?:f\e(B)       \e$,1;6;A;#;?;,;G\e(B
 -Polish  (j\e,Bj\e(Bzyk polski)  Dzie\e,Bq\e(B dobry! / Cze\e,B6f\e(B!
 -Russian (\e,L`caaZXY\e(B)       \e,L7T`P\e$(O+Z\e,LRabRcYbU\e(B!
 -Sinhala (\e$,1B#B2ABB$A}\e(B)   \e$,1AFAzB4AvB=B AqB*\e(B
 -Slovak (sloven\e,Bh\e(Bina)     Dobr\e,A}\e(B de\e,Br\e(B
 -Slovenian (sloven\e,B9h\e(Bina) Pozdravljeni!
 -Spanish (espa\e,Aq\e(Bol)       \e,A!\e(BHola!
 -Swedish (svenska)     Hej / Goddag / Hall\e,Ae\e(B
 -Tamil (\e$,1<D<N<_<T<m\e(B)     \e$,1<U<C<5<m<5<N<m\e(B
 -Telugu (\e$,1=d>&=r>!=W>!\e(B)  \e$,1=h=n=x>-=U=~=p=B\e(B
 -Thai (\e,T@RIRd7B\e(B)  \e,TJGQJ4U$CQ:\e(B / \e,TJGQJ4U$hP\e(B
 -Tibetan (\e$(7"7"]"2!;"G#!"2!;\e(B)     \e$(7"7"!#C!;"E"S"G!;"7"2"[!;"D"["#"G!>\e(B
 -Tigrigna (\e$,1NUP-MmN{\e(B)    \e$,1MpMKM[NU\e(B
 -Turkish (T\e,A|\e(Brk\e,Ag\e(Be)  Merhaba
 -Ukrainian (\e,LcZ`Pw]alZP\e(B)  \e,L2vbPn\e(B
 -Vietnamese (ti\e,1*\e(Bng Vi\e,1.\e(Bt)   Ch\e,A`\e(Bo b\e,1U\e(Bn
 -
 -Japanese (\e$BF|K\8l\e(B)       \e$B$3$s$K$A$O\e(B / \e(I:]FAJ\e(B
 -Chinese (\e$AVPND\e(B,\e$AFUM(;0\e(B,\e$A::So\e(B)  \e$ADc:C\e(B
 -Cantonese (\e$(0GnM$\e(B,\e$(0N]0*Hd\e(B) \e$(0*/=(\e(B, \e$(0+$)p\e(B
 -Korean (\e$(CGQ1[\e(B)  \e$(C>H3gGO<<?d\e(B / \e$(C>H3gGO=J4O1n\e(B
 -
 -\f
 +
 +Emoji 👋
 +</x-charset>English <x-charset><param>ipa</param>/ˈɪŋɡlɪʃ/</x-charset>  Hello
 +<x-charset><param>latin-iso8859-3</param>Esperanto    Saluton (Eĥoŝanĝo ĉiuĵaŭde)
 +</x-charset><x-charset><param>latin-iso8859-15</param>Estonian (eesti keel)   Tere päevast / Tere õhtust
 +</x-charset><x-charset><param>latin-iso8859-1</param>Finnish (suomi)  Hei / Hyvää päivää
 +French (français)    Bonjour / Salut
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Georgian (ქართველი)       გამარჯობა
 +</x-charset><x-charset><param>latin-iso8859-1</param>German (Deutsch) Guten Tag / Grüß Gott
 +</x-charset><x-charset><param>greek-iso8859-7</param>Greek (ελληνικά) Γειά σας
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Greek, ancient (ἑλληνική)        Οὖλέ τε καὶ μέγα χαῖρε
 +Gujarati (ગુજરાતી)      નમસ્તે
 +</x-charset><x-charset><param>hebrew-iso8859-8</param>Hebrew (עברית)     שלום
 +</x-charset><x-charset><param>latin-iso8859-2</param>Hungarian (magyar)       Szép jó napot!
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Hindi (हिंदी)   नमस्ते / नमस्कार ।
 +</x-charset><x-charset><param>unicode</param>Inuktitut (ᐃᓄᒃᑎᑐᑦ)   ᐊᐃ
 +
 +</x-charset><x-charset><param>latin-iso8859-1</param>Italian (italiano)       Ciao / Buon giorno
 +</x-charset>Javanese (Jawa)   System.out.println("Sugeng siang!");
 +<x-charset><param>mule-unicode-0100-24ff</param>Kannada (ಕನ್ನಡ)     ನಮಸ್ಕಾರ
 +Khmer (ភាសាខ្មែរ)   ជំរាបសួរ
 +</x-charset><x-charset><param>lao</param>Lao (ພາສາລາວ)  ສະບາຍດີ / ຂໍໃຫ້ໂຊກດີ
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Malayalam (മലയാളം)    നമസ്കാരം
 +</x-charset><x-charset><param>unicode</param>Maldivian (ދިވެހި) އައްސަލާމު ޢަލައިކުމް / ކިހިނެހް؟
 +
 +</x-charset><x-charset><param>latin-iso8859-3</param>Maltese (il-Malti)       Bonġu / Saħħa
 +</x-charset><x-charset><param>unicode</param>Mathematics      ∀ p ∈ world • hello p  □
 +</x-charset><x-charset><param>cyrillic-iso8859-5</param>Mongolian (монгол хэл)       Сайн байна уу?
 +</x-charset><x-charset><param>latin-iso8859-1</param>Norwegian (norsk)        Hei / God dag
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Oriya (ଓଡ଼ିଆ)      ଶୁଣିବେ
 +</x-charset><x-charset><param>latin-iso8859-2</param>Polish  (język polski)  Dzień dobry! / Cześć!
 +</x-charset><x-charset><param>cyrillic-iso8859-5</param>Russian (русский)      Здра́вствуйте!
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Sinhala (සිංහල) ආයුබෝවන්
 +</x-charset><x-charset><param>latin-iso8859-2</param>Slovak (slovenčina)     Dobrý deň
 +Slovenian (slovenščina)     Pozdravljeni!
 +Spanish (espa</x-charset><x-charset><param>latin-iso8859-1</param>ñol)       ¡Hola!
 +Swedish (svenska)     Hej / Goddag / Hallå
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Tamil (தமிழ்)   வணக்கம்
 +Telugu (తెలుగు)   నమస్కారం
 +</x-charset><x-charset><param>thai-tis620</param>Thai (ภาษาไทย) สวัสดีครับ / สวัสดีค่ะ
 +</x-charset><x-charset><param>tibetan</param>Tibetan (བོད་སྐད་)       བཀྲ་ཤིས་བདེ་ལེགས༎
 +</x-charset><x-charset><param>mule-unicode-0100-24ff</param>Tigrigna (ትግርኛ)   ሰላማት
 +</x-charset><x-charset><param>latin-iso8859-9</param>Turkish (Türkçe)       Merhaba
 +</x-charset><x-charset><param>cyrillic-iso8859-5</param>Ukrainian (українська)      Вітаю
 +</x-charset><x-charset><param>vietnamese-viscii-lower</param>Vietnamese (tiếng </x-charset><x-charset><param>vietnamese-viscii-upper</param>V</x-charset><x-charset><param>vietnamese-viscii-lower</param>iệt)    </x-charset><x-charset><param>vietnamese-viscii-upper</param>Chào bạn
 +
 +</x-charset>
 +
 +<x-charset><param>japanese-jisx0208</param>Japanese (日本語)       こんにちは</x-charset> <x-charset><param>katakana-jisx0201</param>/ ｺﾝﾆﾁﾊ
 +</x-charset><x-charset><param>chinese-gb2312</param>Chinese (中文,普通话,汉语) 你好
 +</x-charset><x-charset><param>chinese-big5-1</param>Cantonese (粵語,廣東話)      早晨, 你好
 +</x-charset><x-charset><param>korean-ksc5601</param>Korean (한글)   안녕하세요 / 안녕하십니까
 +
 +</x-charset>
 +
 +<x-charset><param>unicode</param>\f
 +
  
- Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 2001-2019 Free Software Foundation, Inc.
  
 +
  This file is part of GNU Emacs.
  
 +
  GNU Emacs is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or

diff --cc etc/NEWS.1-17
Simple merge

diff --cc etc/NEWS.18
Simple merge

diff --cc etc/NEWS.19
Simple merge

diff --cc etc/NEWS.20
Simple merge

diff --cc etc/NEWS.26
index 55bdaf111725ab590a10d326a25cfdde99568088,0000000000000000000000000000000000000000..9ee1a4f284e1a45b65e55d68cf1f655c6db4dbde
mode 100644,000000..100644
--- 1/etc/NEWS.26
--- /dev/null
+++ b/etc/NEWS.26
@@@ -1,1946 -1,0 +1,1946 @@@
- Copyright (C) 2016-2018 Free Software Foundation, Inc.
 +GNU Emacs NEWS -- history of user-visible changes.
 +
++Copyright (C) 2016-2019 Free Software Foundation, Inc.
 +See the end of the file for license conditions.
 +
 +Please send Emacs bug reports to 'bug-gnu-emacs@gnu.org'.
 +If possible, use 'M-x report-emacs-bug'.
 +
 +This file is about changes in Emacs version 26.
 +
 +See file HISTORY for a list of GNU Emacs versions and release dates.
 +See files NEWS.25, NEWS.24, ..., NEWS.18, and NEWS.1-17 for changes
 +in older Emacs versions.
 +
 +You can narrow news to a specific version by calling 'view-emacs-news'
 +with a prefix argument or by typing 'C-u C-h C-n'.
 +
 +\f
 +* Installation Changes in Emacs 26.2
 +
 +---
 +** Building Emacs with the '--with-xwidgets' option now requires WebKit2.
 +To build Emacs with xwidgets support, you will need to install the
 +webkit2gtk-4.0 package; version 2.12 or later is required.
 +(This change was actually made in Emacs 26.1, but was not called out
 +in its NEWS.)
 +
 ++++
 +** Installing Emacs now installs the emacs-module.h file.
 +The emacs-module.h file is now installed in the system-wide include
 +directory as part of the Emacs installation.  This allows to build
 +Emacs modules outside of the Emacs source tree.
 +
 +\f
 +* Startup Changes in Emacs 26.2
 +
 +\f
 +* Changes in Emacs 26.2
 +
 +---
 +** Emacs is now compliant with the latest version 11.0 of the Unicode Standard.
 +
 +---
 +** New variable 'xft-ignore-color-fonts'.
 +Default t means don't try to load color fonts when using Xft, as they
 +often cause crashes.  Set it to nil if you really need those fonts.
 +
 +\f
 +* Editing Changes in Emacs 26.2
 +
 +\f
 +* Changes in Specialized Modes and Packages in Emacs 26.2
 +
 +** Dired
 +
 ++++
 +*** The 'Z' command on a directory name compresses all of its files.
 +It produces a compressed '.tar.gz' archive with all the files in the
 +directory and all of its subdirectories.  For symmetry, 'Z' on a
 +'.tar.gz' or a '.tgz' archive extracts all the archived files into the
 +current directory; thus, typing 'Z' on a '.tar.gz' archive created by
 +a previous 'Z' command will extract the archived files into a
 +directory whose name is the archive name sans the '.tar.gz' extension.
 +(This change was actually made in Emacs 25.1 but was only
 +partially called out in its NEWS; 'tgz' handling was added in 26.1.)
 +
 +** Ibuffer
 +
 +---
 +*** New toggle 'ibuffer-do-toggle-lock', bound to 'L'.
 +
 +** Imenu
 +
 +---
 +*** The value for 'imenu-auto-rescan-maxout' has been increased to 600000.
 +
 +** Gnus
 +
 +---
 +*** Mailutils movemail will now be used if found at runtime.
 +The default value of 'mail-source-movemail-program' is now "movemail".
 +This ensures that the movemail program from GNU Mailutils will be used
 +if found in 'exec-path', even if it was not found at build time.  To
 +use a different program, customize 'mail-source-movemail-program' to the
 +absolute file name of the desired executable.
 +
 +** Shadowfile
 +
 +---
 +*** shadowfile.el has been rewritten to support Tramp file names.
 +
 +** Shell mode
 +
 +---
 +*** Shell mode buffers now have 'scroll-conservatively' set to 101.
 +This is so as to better emulate the scrolling behavior of a text
 +terminal when new output is added to the screen buffer.  To get back
 +the previous behavior, reset 'scroll-conservatively' to zero (or any
 +other value you like) in a function and add it to 'shell-mode-hook'.
 +(This change was actually made in Emacs 26.1, but was not called out
 +in its NEWS.)
 +
 +** VC
 +
 +---
 +*** VC support for Mercurial was improved.
 +Emacs now avoids invoking 'hg' as much as possible, for faster operation.
 +(This and the following changes were actually made in Emacs 26.1, but
 +were not called out in its NEWS.)
 +
 +---
 +**** New vc-hg options.
 +The new option 'vc-hg-parse-hg-data-structures' controls whether vc-hg
 +will try parsing the Mercurial data structures directly instead of
 +running 'hg'; it defaults to t (set to nil if you want the pre-26.1
 +behavior).
 +The new option 'vc-hg-symbolic-revision-styles' controls how versions
 +in a Mercurial repository are presented symbolically on the mode line.
 +The new option 'vc-hg-use-file-version-for-mode-line-version' controls
 +whether the version shown on the mode line is that of the visited file
 +or of the repository working copy.
 +
 +---
 +**** Display of Mercurial revisions in the mode line has changed.
 +Previously, the mode line displayed the local number (1, 2, 3, ...) of
 +the revision.  Starting with Emacs 26.1, the default has changed, and
 +it now shows the global revision number, in the form of its changeset
 +hash value.  To get back the previous behavior, customize the new
 +option 'vc-hg-symbolic-revision-styles' to the value '("{rev}")'.
 +
 +\f
 +* New Modes and Packages in Emacs 26.2
 +
 +\f
 +* Incompatible Lisp Changes in Emacs 26.2
 +
 +---
 +** shadowfile config files have changed their syntax.
 +Existing files "~/.emacs.d/shadows" and "~/.emacs.d/shadow_todo" must
 +be removed prior using the changed 'shadow-*' commands.
 +
 ++++
 +** 'thread-alive-p' has been renamed to 'thread-live-p'.
 +The old name is an alias of the new name.  Future Emacs version will
 +obsolete it.
 +
 +---
 +** 'while-no-input' does not return due to input from subprocesses.
 +Input that arrived from subprocesses while some code executed inside
 +the 'while-no-input' form injected an internal buffer-switch event
 +that counted as input and would cause 'while-no-input' to return,
 +perhaps prematurely.  These buffer-switch events are now by default
 +ignored by 'while-no-input'; if you need to get the old behavior,
 +remove 'buffer-switch' from the list of events in
 +'while-no-input-ignore-events'.
 +
 +\f
 +* Lisp Changes in Emacs 26.2
 +
 ++++
 +** The new function 'read-answer' accepts either long or short answers
 +depending on the new customizable variable 'read-answer-short'.
 +
 ++++
 +** New function 'assoc-delete-all'.
 +Like 'assq-delete-all', but uses 'equal' for comparison.
 +
 +---
 +** The function 'thing-at-point' behaves as before Emacs 26.1.
 +The behavior of 'thing-at-point' when called with argument 'list' has
 +changed in Emacs 26.1, in that it didn't consider text inside comments
 +and strings as a potential list.  This change is now reverted, and
 +'thing-at-point' behaves like it did before Emacs 26.1.
 +
 +---
 +** To cater to use cases where comments and strings are to be ignored
 +when looking for a list, the function 'list-at-point' now takes an
 +optional argument to do so.
 +
 +\f
 +* Changes in Emacs 26.2 on Non-Free Operating Systems
 +
 +** macOS features can now be detected at run-time as well as at
 +build-time.  See nextstep/INSTALL for details.
 +(This change was actually made in Emacs 26.1, but was undocumented and
 +not called out in its NEWS.)
 +
 +\f
 +* Installation Changes in Emacs 26.1
 +
 +** By default libgnutls is now required when building Emacs.
 +Use 'configure --with-gnutls=no' to build even when GnuTLS is missing.
 +
 +** GnuTLS version 2.12.2 or later is now required, instead of merely
 +version 2.6.6 or later.
 +
 +** The new option 'configure --with-mailutils' causes Emacs to rely on
 +GNU Mailutils to retrieve email.  It is recommended, and is the
 +default if GNU Mailutils is installed.  When '--with-mailutils' is not
 +in effect, the Emacs build procedure by default continues to build and
 +install a limited 'movemail' substitute that retrieves POP3 email only
 +via insecure channels.  To avoid this problem, use either
 +'--with-mailutils' or '--without-pop' when configuring; '--without-pop'
 +is the default on platforms other than native MS-Windows.
 +
 +** The new option 'configure --enable-gcc-warnings=warn-only' causes
 +GCC to issue warnings without stopping the build.  This behavior is
 +now the default in developer builds.  As before, use
 +'--disable-gcc-warnings' to suppress GCC's warnings, and
 +'--enable-gcc-warnings' to stop the build if GCC issues warnings.
 +
 +** When GCC warnings are enabled, '--enable-check-lisp-object-type' is
 +now enabled by default when configuring.
 +
 +** The Emacs server now has socket-launching support.
 +This allows socket based activation, where an external process like
 +systemd can invoke the Emacs server process upon a socket connection
 +event and hand the socket over to Emacs.  Emacs uses this socket to
 +service emacsclient commands.  This new functionality can be disabled
 +with the configure option '--disable-libsystemd'.
 +
 +** A systemd user unit file is provided.
 +Use it in the standard way: 'systemctl --user enable emacs'.  (If your
 +Emacs is installed in a non-standard location, you may need to copy
 +the emacs.service file to eg ~/.config/systemd/user/)
 +
 +** New configure option '--disable-build-details' attempts to build an
 +Emacs that is more likely to be reproducible; that is, if you build
 +and install Emacs twice, the second Emacs is a copy of the first.
 +Deterministic builds omit the build date from the output of the
 +'emacs-version' and 'erc-cmd-SV' functions, and the leave the
 +following variables nil: 'emacs-build-system', 'emacs-build-time',
 +'erc-emacs-build-time'.
 +
 +** Emacs can now be built with support for Little CMS.
 +If the lcms2 library is installed, Emacs will enable features built on
 +top of that library.  The new configure option '--without-lcms2' can
 +be used to build without lcms2 support even if it is installed.  Emacs
 +linked to Little CMS exposes color management functions in Lisp: the
 +color metrics 'lcms-cie-de2000' and 'lcms-cam02-ucs', as well as
 +functions for conversion to and from CIE CAM02 and CAM02-UCS.
 +
 +** The configure option '--with-gameuser' now defaults to 'no',
 +as this appears to be the most common configuration in practice.
 +When it is 'no', the shared game directory and the auxiliary program
 +update-game-score are no longer needed and are not installed.
 +
 +** Emacs no longer works on IRIX.  We expect that Emacs users are not
 +affected by this, as SGI stopped supporting IRIX in December 2013.
 +
 +\f
 +* Startup Changes in Emacs 26.1
 +
 +** New option '--fg-daemon'.  This is the same as '--daemon', except
 +it runs in the foreground and does not fork.  This is intended for
 +modern init systems such as systemd, which manage many of the traditional
 +aspects of daemon behavior themselves.  '--bg-daemon' is now an alias
 +for '--daemon'.
 +
 +** New option '--module-assertions'.
 +When given this option, Emacs will perform expensive correctness
 +checks when dealing with dynamic modules.  This is intended for module
 +authors that wish to verify that their module conforms to the module
 +requirements.  The option makes Emacs abort if a module-related
 +assertion triggers.
 +
 +** Emacs now supports 24-bit colors on capable text terminals.
 +Terminal is automatically initialized to use 24-bit colors if the
 +required capabilities are found in terminfo.  See the FAQ node
 +"(efaq) Colors on a TTY" for more information.
 +
 +** Emacs now obeys the X resource "scrollBar" at startup.
 +The effect is similar to that of "toolBar" resource on the tool bar.
 +
 +\f
 +* Changes in Emacs 26.1
 +
 +** Option 'buffer-offer-save' can be set to new value, 'always'.
 +When set to 'always', the command 'save-some-buffers' will always
 +offer this buffer for saving.
 +
 +** Security vulnerability related to Enriched Text mode is removed.
 +
 +*** Enriched Text mode does not evaluate Lisp in 'display' properties.
 +This feature allows saving 'display' properties as part of text.
 +Emacs 'display' properties support evaluation of arbitrary Lisp forms
 +as part of processing the property for display, so displaying Enriched
 +Text could be vulnerable to executing arbitrary malicious Lisp code
 +included in the text (e.g., sent as part of an email message).
 +Therefore, execution of arbitrary Lisp forms in 'display' properties
 +decoded by Enriched Text mode is now disabled by default.  Customize
 +the new option 'enriched-allow-eval-in-display-props' to a non-nil
 +value to allow Lisp evaluation in decoded 'display' properties.
 +
 +This vulnerability was introduced in Emacs 21.1.  To work around that
 +in Emacs versions before 25.3, append the following to your ~/.emacs
 +init file:
 +
 +  (eval-after-load "enriched"
 +    '(defun enriched-decode-display-prop (start end &optional param)
 +       (list start end)))
 +
 +** Functions in 'write-contents-functions' can fully short-circuit the
 +'save-buffer' process.  Previously, saving a buffer that was not
 +visiting a file would always prompt for a file name.  Now it only does
 +so if 'write-contents-functions' is nil (or all its functions return
 +nil).
 +
 +** New variable 'executable-prefix-env' for inserting magic signatures.
 +This variable affects the format of the interpreter magic number
 +inserted by 'executable-set-magic'.  If non-nil, the magic number now
 +takes the form "#!/usr/bin/env interpreter", otherwise the value
 +determined by 'executable-prefix', which is by default
 +"#!/path/to/interpreter".  By default, 'executable-prefix-env' is nil,
 +so the default behavior is not changed.
 +
 +** The variable 'emacs-version' no longer includes the build number.
 +This is now stored separately in a new variable, 'emacs-build-number'.
 +
 +** Emacs now provides a limited form of concurrency with Lisp threads.
 +Concurrency in Emacs Lisp is "mostly cooperative", meaning that
 +Emacs will only switch execution between threads at well-defined
 +times: when Emacs waits for input, during blocking operations related
 +to threads (such as mutex locking), or when the current thread
 +explicitly yields.  Global variables are shared among all threads, but
 +a 'let' binding is thread-local.  Each thread also has its own current
 +buffer and its own match data.
 +
 +See the chapter "(elisp) Threads" in the ELisp manual for full
 +documentation of these facilities.
 +
 +** The new user variable 'electric-quote-chars' provides a list
 +of curved quotes for 'electric-quote-mode', allowing user to choose
 +the types of quotes to be used.
 +
 +** The new user option 'electric-quote-context-sensitive' makes
 +'electric-quote-mode' context sensitive.  If it is non-nil, you can
 +type an ASCII apostrophe to insert an opening or closing quote,
 +depending on context.  Emacs will replace the apostrophe by an opening
 +quote character at the beginning of the buffer, the beginning of a
 +line, after a whitespace character, and after an opening parenthesis;
 +and it will replace the apostrophe by a closing quote character in all
 +other cases.
 +
 +** The new variable 'electric-quote-inhibit-functions' controls when
 +to disable electric quoting based on context.  Major modes can add
 +functions to this list; Emacs will temporarily disable
 +'electric-quote-mode' whenever any of the functions returns non-nil.
 +This can be used by major modes that derive from 'text-mode' but allow
 +inline code segments, such as 'markdown-mode'.
 +
 +** The new user variable 'dired-omit-case-fold' allows the user to
 +customize the case-sensitivity of dired-omit-mode.  It defaults to
 +the same sensitivity as that of the filesystem for the corresponding
 +dired buffer.
 +
 +** Emacs now uses double buffering to reduce flicker when editing and
 +resizing graphical Emacs frames on the X Window System.  This support
 +requires the DOUBLE-BUFFER extension, which major X servers have
 +supported for many years.  If your system has this extension, but an
 +Emacs built with double buffering misbehaves on some displays you use,
 +you can disable the feature by adding
 +
 +  '(inhibit-double-buffering . t)
 +
 +to default-frame-alist.  Or inject this parameter into the selected
 +frame by evaluating this form:
 +
 +  (modify-frame-parameters nil '((inhibit-double-buffering . t)))
 +
 +** The customization group 'wp', whose label was "text", is now
 +deprecated.  Use the new group 'text', which inherits from 'wp',
 +instead.
 +
 +** The new function 'call-shell-region' executes a command in an
 +inferior shell with the buffer region as input.
 +
 +** The new user option 'shell-command-dont-erase-buffer' controls
 +if the output buffer is erased between shell commands; if non-nil,
 +the output buffer is not erased; this variable also controls where
 +to set the point in the output buffer: beginning of the output,
 +end of the buffer or save the point.
 +When 'shell-command-dont-erase-buffer' is nil, the default value,
 +the behavior of 'shell-command', 'shell-command-on-region' and
 +'async-shell-command' is as usual.
 +
 +** The new user option 'async-shell-command-display-buffer' controls
 +whether the output buffer of an asynchronous command is shown
 +immediately, or only when there is output.
 +
 +** New user option 'mouse-select-region-move-to-beginning'.
 +This option controls the position of point when double-clicking
 +mouse-1 on the end of a parenthetical grouping or string-delimiter:
 +the default value nil keeps point at the end of the region, setting it
 +to non-nil moves point to the beginning of the region.
 +
 +** New user option 'mouse-drag-and-drop-region'.
 +This option allows you to drag the entire region of text to another
 +place or another buffer.  Its behavior is customizable via the new
 +options 'mouse-drag-and-drop-region-cut-when-buffers-differ',
 +'mouse-drag-and-drop-region-show-tooltip', and
 +'mouse-drag-and-drop-region-show-cursor'.
 +
 +** The new user option 'confirm-kill-processes' allows the user to
 +skip a confirmation prompt for killing subprocesses when exiting
 +Emacs.  When set to t (the default), Emacs will prompt for
 +confirmation before killing subprocesses on exit, which is the same
 +behavior as before.
 +
 +** 'find-library-name' will now fall back on looking at 'load-history'
 +to try to locate libraries that have been loaded with an explicit path
 +outside 'load-path'.
 +
 +** Faces in 'minibuffer-prompt-properties' no longer overwrite properties
 +in the text in functions like 'read-from-minibuffer', but instead are
 +added to the end of the face list.  This allows users to say things
 +like '(read-from-minibuffer (propertize "Enter something: " 'face 'bold))'.
 +
 +** The new variable 'extended-command-suggest-shorter' has been added
 +to control whether to suggest shorter 'M-x' commands or not.
 +
 +** icomplete now respects 'completion-ignored-extensions'.
 +
 +** Non-breaking hyphens are now displayed with the 'nobreak-hyphen'
 +face instead of the 'escape-glyph' face.
 +
 +** Approximations to quotes are now displayed with the new 'homoglyph'
 +face instead of the 'escape-glyph' face.
 +
 +** New face 'header-line-highlight'.
 +This face is the header-line analogue of 'mode-line-highlight'; it
 +should be the preferred mouse-face for mouse-sensitive elements in the
 +header line.
 +
 +** 'C-x h' ('mark-whole-buffer') will now avoid marking the prompt
 +part of minibuffers.
 +
 +** 'fill-paragraph' no longer marks the buffer as changed unless it
 +actually changed something.
 +
 +** The locale language name 'ca' is now mapped to the language
 +environment 'Catalan', which has been added.
 +
 +** 'align-regexp' has a separate history for its interactive argument.
 +'align-regexp' no longer shares its history with all other
 +history-less functions that use 'read-string'.
 +
 +** The networking code has been reworked so that it's more
 +asynchronous than it was (when specifying :nowait t in
 +'make-network-process').  How asynchronous it is varies based on the
 +capabilities of the system, but on a typical GNU/Linux system the DNS
 +resolution, the connection, and (for TLS streams) the TLS negotiation
 +are all done without blocking the main Emacs thread.  To get
 +asynchronous TLS, the TLS boot parameters have to be passed in (see
 +the manual for details).
 +
 +Certain process oriented functions (like 'process-datagram-address')
 +will block until socket setup has been performed.  The recommended way
 +to deal with asynchronous sockets is to avoid interacting with them
 +until they have changed status to "run".  This is most easily done
 +from a process sentinel.
 +
 +** 'make-network-process' and 'open-network-stream' sometimes allowed
 +:service to be an integer string (e.g., :service "993") and sometimes
 +required an integer (e.g., :service 993).  This difference has been
 +eliminated, and integer strings work everywhere.
 +
 +** It is possible to disable attempted recovery on fatal signals.
 +Two new variables support disabling attempts to recover from stack
 +overflow and to avoid automatic auto-save when Emacs is delivered a
 +fatal signal.  'attempt-stack-overflow-recovery', if set to nil,
 +will disable attempts to recover from C stack overflows; Emacs will
 +then crash as with any other fatal signal.
 +'attempt-orderly-shutdown-on-fatal-signal', if set to nil, will
 +disable attempts to auto-save the session and shut down in an orderly
 +fashion when Emacs receives a fatal signal; instead, Emacs will
 +terminate immediately.  Both variables are non-nil by default.
 +These variables are for users who would like to avoid the small
 +probability of data corruption due to techniques Emacs uses to recover
 +in these situations.
 +
 +** File local and directory local variables are now initialized each
 +time the major mode is set, not just when the file is first visited.
 +These local variables will thus not vanish on setting a major mode.
 +
 +** A second dir-local file (.dir-locals-2.el) is now accepted.
 +See the doc string of 'dir-locals-file' for more information.
 +
 +** Connection-local variables can be used to specify local variables
 +with a value depending on the connected remote server.  For details,
 +see the node "(elisp) Connection Local Variables" in the ELisp manual.
 +
 +** International domain names (IDNA) are now encoded via the new
 +puny.el library, so that one can visit Web sites with non-ASCII URLs.
 +
 +** The new 'list-timers' command lists all active timers in a buffer,
 +where you can cancel them with the 'c' command.
 +
 +** 'switch-to-buffer-preserve-window-point' now defaults to t.
 +Applications that call 'switch-to-buffer' and want to show the buffer at
 +the position of its point should use 'pop-to-buffer-same-window' in lieu
 +of 'switch-to-buffer'.
 +
 +** The new variable 'debugger-stack-frame-as-list' allows displaying
 +all call stack frames in a Lisp backtrace buffer as lists.  Both
 +debug.el and edebug.el have been updated to heed to this variable.
 +
 +** Values in call stack frames are now displayed using 'cl-prin1'.
 +The old behavior of using 'prin1' can be restored by customizing the
 +new option 'debugger-print-function'.
 +
 +** NUL bytes in text copied to the system clipboard are now replaced with "\0".
 +
 +** The new variable 'x-ctrl-keysym' has been added to the existing
 +roster of X keysyms.  It can be used in combination with another
 +variable of this kind to swap modifiers in Emacs.
 +
 +** New input methods: 'cyrillic-tuvan', 'polish-prefix', 'uzbek-cyrillic'.
 +
 +** The 'dutch' input method no longer attempts to support Turkish too.
 +Also, it no longer converts 'IJ' and 'ij' to the compatibility
 +characters U+0132 LATIN CAPITAL LIGATURE IJ and U+0133 LATIN SMALL
 +LIGATURE IJ.
 +
 +** File name quoting by adding the prefix "/:" is now possible for the
 +local part of a remote file name.  Thus, if you have a directory named
 +"/~" on the remote host "foo", you can prevent it from being
 +substituted by a home directory by writing it as "/foo:/:/~/file".
 +
 +** The new variable 'maximum-scroll-margin' allows having effective
 +settings of 'scroll-margin' up to half the window size, instead of
 +always restricting the margin to a quarter of the window.
 +
 +** Emacs can scroll horizontally using mouse, touchpad, and trackbar.
 +You can enable this by customizing 'mouse-wheel-tilt-scroll'.  If you
 +want to reverse the direction of the scroll, customize
 +'mouse-wheel-flip-direction'.
 +
 +** The default GnuTLS priority string now includes %DUMBFW.
 +This is to avoid bad behavior in some firewalls, which causes the
 +connection to be closed by the remote host.
 +
 +** Emacsclient changes
 +
 +*** Emacsclient has a new option '-u' / '--suppress-output'.
 +This option suppresses display of return values from the server
 +process.
 +
 +*** Emacsclient has a new option '-T' / '--tramp'.
 +This helps with using a local Emacs session as the server for a remote
 +emacsclient.  With appropriate setup, one can now set the EDITOR
 +environment variable on a remote machine to emacsclient, and
 +use the local Emacs to edit remote files via Tramp.  See the node
 +"(emacs) emacsclient Options" in the user manual for the details.
 +
 +*** Emacsclient now accepts command-line options in ALTERNATE_EDITOR
 +and '--alternate-editor'. For example, ALTERNATE_EDITOR="emacs -Q -nw".
 +Arguments may be quoted "like this", so that for example an absolute
 +path containing a space may be specified; quote escaping is not
 +supported.
 +
 +** New user option 'dig-program-options' and extended functionality
 +for DNS-querying functions 'nslookup-host', 'dns-lookup-host',
 +and 'run-dig'.  Each function now accepts an optional name server
 +argument interactively (with a prefix argument) and non-interactively.
 +
 +** 'describe-key-briefly' now ignores mouse movement events.
 +
 +** The new variable 'eval-expression-print-maximum-character' prevents
 +large integers from being displayed as characters by 'M-:' and similar
 +commands.
 +
 +** Two new commands for finding the source code of Emacs Lisp
 +libraries: 'find-library-other-window' and 'find-library-other-frame'.
 +
 +** The new variable 'display-raw-bytes-as-hex' allows you to change
 +the display of raw bytes from octal to hex.
 +
 +** You can now provide explicit field numbers in format specifiers.
 +For example, '(format "%2$s %1$s %2$s" "X" "Y")' produces "Y X Y".
 +
 +** Emacs now supports optional display of line numbers in the buffer.
 +This is similar to what 'linum-mode' provides, but much faster and
 +doesn't usurp the display margin for the line numbers.  Customize the
 +buffer-local variable 'display-line-numbers' to activate this optional
 +display.  Alternatively, you can use the 'display-line-numbers-mode'
 +minor mode or the global 'global-display-line-numbers-mode'.  When
 +using these modes, customize 'display-line-numbers-type' with the same
 +value as you would use with 'display-line-numbers'.
 +
 +Line numbers are not displayed at all in minibuffer windows and in
 +tooltips, as they are not useful there.
 +
 +Lisp programs can disable line-number display for a particular screen
 +line by putting the 'display-line-numbers-disable' text property or
 +overlay property on the first character of that screen line.  This is
 +intended for add-on packages that need a finer control of the display.
 +
 +Lisp programs that need to know how much screen estate is used up for
 +line-number display in a window can use the new function
 +'line-number-display-width'.
 +
 +'linum-mode' and all similar packages are henceforth becoming obsolete.
 +Users and developers are encouraged to switch to this new feature
 +instead.
 +
 +** The new user option 'arabic-shaper-ZWNJ-handling' controls how to
 +handle ZWNJ in Arabic text rendering.
 +
 +\f
 +* Editing Changes in Emacs 26.1
 +
 +** New variable 'column-number-indicator-zero-based'.
 +Traditionally, in Column Number mode, the displayed column number
 +counts from zero starting at the left margin of the window.  This
 +behavior is now controlled by 'column-number-indicator-zero-based'.
 +If you would prefer for the displayed column number to count from one,
 +you may set this variable to nil.  (Behind the scenes, there is now a
 +new mode line construct, '%C', which operates exactly as '%c' does
 +except that it counts from one.)
 +
 +** New single-line horizontal scrolling mode.
 +The 'auto-hscroll-mode' variable can now have a new special value,
 +'current-line', which causes only the line where the cursor is
 +displayed to be horizontally scrolled when lines are truncated on
 +display and point moves outside the left or right window margin.
 +
 +** New mode line constructs '%o' and '%q', and user option
 +'mode-line-percent-position'.  '%o' displays the "degree of travel" of
 +the window through the buffer.  Unlike the default '%p', this
 +percentage approaches 100% as the window approaches the end of the
 +buffer.  '%q' displays the percentage offsets of both the start and
 +the end of the window, e.g. "5-17%".  The new option
 +'mode-line-percent-position' makes it easier to switch between '%p',
 +'%P', and these new constructs.
 +
 +** Two new user options 'list-matching-lines-jump-to-current-line' and
 +'list-matching-lines-current-line-face' to show the current line
 +highlighted in *Occur* buffer.
 +
 +** The 'occur' command can now operate on the region.
 +
 +** New bindings for 'query-replace-map'.
 +'undo', undo the last replacement; bound to 'u'.
 +'undo-all', undo all replacements; bound to 'U'.
 +
 +** 'delete-trailing-whitespace' deletes whitespace after form feed.
 +In modes where form feed was treated as a whitespace character,
 +'delete-trailing-whitespace' would keep lines containing it unchanged.
 +It now deletes whitespace after the last form feed thus behaving the
 +same as in modes where the character is not whitespace.
 +
 +** Emacs no longer prompts about editing a changed file when the file's
 +content is unchanged.  Instead of only checking the modification time,
 +Emacs now also checks the file's actual content before prompting the user.
 +
 +** Various casing improvements.
 +
 +*** 'upcase', 'upcase-region' et al. convert title case characters
 +(such as Dz) into their upper case form (such as DZ).
 +
 +*** 'capitalize', 'upcase-initials' et al. make use of title-case forms
 +of initial characters (correctly producing for example Džungla instead
 +of incorrect DŽungla).
 +
 +*** Characters which turn into multiple ones when cased are correctly handled.
 +For example, fi ligature is converted to FI when upper cased.
 +
 +*** Greek small sigma is correctly handled when at the end of the word.
 +Strings such as ΌΣΟΣ are now correctly converted to Όσος when
 +capitalized instead of incorrect Όσοσ (compare lowercase sigma at the
 +end of the word).
 +
 +** Emacs can now auto-save buffers to visited files in a more robust
 +manner via the new mode 'auto-save-visited-mode'.  Unlike
 +'auto-save-visited-file-name', this mode uses the normal saving
 +procedure and therefore obeys saving hooks.
 +'auto-save-visited-file-name' is now obsolete.
 +
 +** New behavior of 'mark-defun'.
 +Prefix argument selects that many (or that many more) defuns.
 +Negative prefix arg flips the direction of selection.  Also,
 +'mark-defun' between defuns correctly selects N following defuns (or
 +-N previous for negative arguments).  Finally, comments preceding the
 +defun are selected unless they are separated from the defun by a blank
 +line.
 +
 +** New command 'replace-buffer-contents'.
 +This command replaces the contents of the accessible portion of the
 +current buffer with the contents of the accessible portion of a
 +different buffer while keeping point, mark, markers, and text
 +properties as intact as possible.
 +
 +** New commands 'apropos-local-variable' and 'apropos-local-value'.
 +These are buffer-local versions of 'apropos-variable' and
 +'apropos-value', respectively.  They show buffer-local variables whose
 +names and values, respectively, match a given pattern.
 +
 +** More user control of reordering bidirectional text for display.
 +The two new variables, 'bidi-paragraph-start-re' and
 +'bidi-paragraph-separate-re', allow customization of what exactly are
 +paragraphs, for the purposes of bidirectional display.
 +
 +** New variable 'x-wait-for-event-timeout'.
 +This controls how long Emacs will wait for updates to the graphical
 +state to take effect (making a frame visible, for example).
 +
 +\f
 +* Changes in Specialized Modes and Packages in Emacs 26.1
 +
 +** Emacs 26.1 comes with Org v9.1.6.
 +See the file ORG-NEWS for user-visible changes in Org.
 +
 +** New function 'cl-generic-p'.
 +
 +** Dired
 +
 +*** You can answer 'all' in 'dired-do-delete' to delete recursively all
 +remaining directories without more prompts.
 +
 +*** Dired supports wildcards in the directory part of the file names.
 +
 +*** You can now use '`?`' in 'dired-do-shell-command'.
 +It gets replaced by the current file name, like ' ? '.
 +
 +*** A new option 'dired-always-read-filesystem' defaulting to nil.
 +If non-nil, buffers visiting files are reverted before they are
 +searched; for instance, in 'dired-mark-files-containing-regexp' a
 +non-nil value of this option means the file is revisited in a
 +temporary buffer; this temporary buffer is the actual buffer searched:
 +the original buffer visiting the file is not modified.
 +
 +*** Users can now customize mouse clicks in Dired in a more flexible way.
 +The new command 'dired-mouse-find-file' can be bound to a mouse click
 +and used to visit files/directories in Dired in the selected window.
 +The new command 'dired-mouse-find-file-other-frame' similarly visits
 +files/directories in another frame.  You can write your own commands
 +that invoke 'dired-mouse-find-file' with non-default optional
 +arguments, to tailor the effects of mouse clicks on file names in
 +Dired buffers.
 +
 +*** In wdired, when editing files to contain slash characters,
 +the resulting directories are automatically created.  Whether to do
 +this is controlled by the 'wdired-create-parent-directories' variable.
 +
 +*** 'W' is now bound to 'browse-url-of-dired-file', and is useful for
 +viewing HTML files and the like.
 +
 +*** New variable 'dired-clean-confirm-killing-deleted-buffers'
 +controls whether Dired asks to kill buffers visiting deleted files and
 +directories.  The default is t, so Dired asks for confirmation, to
 +keep previous behavior.
 +
 +** html2text is now marked obsolete.
 +
 +** smerge-refine-regions can refine regions in separate buffers.
 +
 +** Info menu and index completion uses substring completion by default.
 +This can be customized via the 'info-menu' category in
 +'completion-category-overrides'.
 +
 +** The ancestor buffer is shown by default in 3-way merges.
 +A new option 'ediff-show-ancestor' and a new toggle
 +'ediff-toggle-show-ancestor'.
 +
 +** TeX: Add luatex and xetex as alternatives to pdftex.
 +
 +** Electric-Buffer-menu
 +
 +*** Key 'U' is bound to 'Buffer-menu-unmark-all' and key 'M-DEL' is
 +bound to 'Buffer-menu-unmark-all-buffers'.
 +
 +** hideshow mode got four key bindings that are analogous to outline
 +mode bindings: 'C-c @ C-a', 'C-c @ C-t', 'C-c @ C-d', and 'C-c @ C-e'.
 +
 +** bs
 +
 +*** Two new commands 'bs-unmark-all', bound to 'U', and
 +'bs-unmark-previous', bound to <backspace>.
 +
 +** Buffer-menu
 +
 +*** Two new commands 'Buffer-menu-unmark-all', bound to 'U' and
 +'Buffer-menu-unmark-all-buffers', bound to 'M-DEL'.
 +
 +** Checkdoc
 +
 +*** 'checkdoc-arguments-in-order-flag' now defaults to nil.
 +
 +** Gnus
 +
 +*** The ~/.newsrc file will now only be saved if the native select
 +method is an NNTP select method.
 +
 +*** A new command for sorting articles by readedness marks has been
 +added: 'C-c C-s C-m C-m'.
 +
 +*** In 'message-citation-line-format' the '%Z' format is now the time
 +zone name instead of the numeric form.  The '%z' format continues to
 +be the numeric form.  The new behavior is compatible with
 +'format-time-string'.
 +
 +** Ibuffer
 +
 +*** New command 'ibuffer-jump'.
 +
 +*** New filter commands 'ibuffer-filter-by-basename',
 +'ibuffer-filter-by-file-extension', 'ibuffer-filter-by-directory',
 +'ibuffer-filter-by-starred-name', 'ibuffer-filter-by-modified'
 +and 'ibuffer-filter-by-visiting-file'; bound respectively
 +to '/b', '/.', '//', '/*', '/i' and '/v'.
 +
 +*** Two new commands 'ibuffer-filter-chosen-by-completion'
 +and 'ibuffer-and-filter', the second bound to '/&'.
 +
 +*** The commands 'ibuffer-pop-filter', 'ibuffer-pop-filter-group',
 +'ibuffer-or-filter' and 'ibuffer-filter-disable' have the alternative
 +bindings '/<up>', '/S-<up>', '/|' and '/DEL', respectively.
 +
 +*** The data format specifying filters has been extended to allow
 +explicit logical 'and', and a more flexible form for logical 'not'.
 +See 'ibuffer-filtering-qualifiers' doc string for full details.
 +
 +*** A new command 'ibuffer-copy-buffername-as-kill'; bound
 +to 'B'.
 +
 +*** New command 'ibuffer-change-marks'; bound to '* c'.
 +
 +*** A new command 'ibuffer-mark-by-locked' to mark
 +all locked buffers;  bound to '% L'.
 +
 +*** A new option 'ibuffer-locked-char' to indicate
 +locked buffers; Ibuffer shows a new column displaying
 +'ibuffer-locked-char' for locked buffers.
 +
 +*** A new command 'ibuffer-unmark-all-marks' to unmark
 +all buffers without asking confirmation;  bound to
 +'U'; 'ibuffer-do-replace-regexp' bound to 'r'.
 +
 +*** A new command 'ibuffer-mark-by-content-regexp' to mark buffers
 +whose content matches a regexp; bound to '% g'.
 +
 +*** Two new options 'ibuffer-never-search-content-name' and
 +'ibuffer-never-search-content-mode' used by
 +'ibuffer-mark-by-content-regexp'.
 +
 +** Browse-URL
 +
 +*** Support for opening links to man pages in Man or WoMan mode.
 +
 +** Comint
 +
 +*** New user option 'comint-move-point-for-matching-input' to control
 +where to place point after 'C-c M-r' and 'C-c M-s'.
 +
 +*** New user option 'comint-terminfo-terminal'.
 +This option allows control of the value of the TERM environment
 +variable Emacs puts into the environment of the Comint mode and its
 +derivatives, such as Shell mode and Compilation Shell minor-mode.  The
 +default is "dumb", for compatibility with previous behavior.
 +
 +** Compilation mode
 +
 +*** Messages from CMake are now recognized.
 +
 +*** The number of errors, warnings, and informational messages is now
 +displayed in the mode line.  These are updated as compilation
 +proceeds.
 +
 +** Grep
 +
 +*** Grep commands will now use GNU grep's '--null' option if
 +available, which allows distinguishing the filename from contents if
 +they contain colons.  This can be controlled by the new custom option
 +'grep-use-null-filename-separator'.
 +
 +*** The grep/rgrep/lgrep functions will now ask about saving files
 +before running.  This is controlled by the 'grep-save-buffers'
 +variable.
 +
 +** Edebug
 +
 +*** Edebug can be prevented from pausing 1 second after reaching a
 +breakpoint (e.g. with "f" and "o") by customizing the new option
 +'edebug-sit-on-break'.
 +
 +*** New customizable option 'edebug-max-depth'.
 +This allows you to enlarge the maximum recursion depth when
 +instrumenting code.
 +
 +*** 'edebug-prin1-to-string' now aliases 'cl-prin1-to-string'.
 +This means edebug output is affected by variables 'cl-print-readably'
 +and 'cl-print-compiled'.  To completely restore the previous printing
 +behavior, use
 +
 +    (fset 'edebug-prin1-to-string #'prin1-to-string)
 +
 +** Eshell
 +
 +*** 'eshell-input-filter's value is now a named function
 +'eshell-input-filter-default', and has a new custom option
 +'eshell-input-filter-initial-space' to ignore adding commands prefixed
 +with blank space to eshell history.
 +
 +** EUDC
 +
 +*** Backward compatibility support for BBDB versions less than 3
 +(i.e., BBDB 2.x) is deprecated and will likely be removed in the next
 +major release of Emacs.  Users of BBDB 2.x should plan to upgrade to
 +BBDB 3.x.
 +
 +** eww
 +
 +*** New 'M-RET' command for opening a link at point in a new eww buffer.
 +
 +*** A new 's' command for switching to another eww buffer via the minibuffer.
 +
 +*** The 'o' command ('shr-save-contents') has moved to 'O' to avoid collision
 +with the 'o' command from 'image-map'.
 +
 +*** A new command 'C' ('eww-toggle-colors') can be used to toggle
 +whether to use the HTML-specified colors or not.  The user can also
 +customize the 'shr-use-colors' variable.
 +
 +*** Images that are being loaded are now marked with gray
 +"placeholder" images of the size specified by the HTML.  They are then
 +replaced by the real images asynchronously, which will also now
 +respect width/height HTML specs (unless they specify widths/heights
 +bigger than the current window).
 +
 +*** The 'w' command on links is now 'shr-maybe-probe-and-copy-url'.
 +'shr-copy-url' now only copies the url at point; users who wish to
 +avoid accidentally accessing remote links may rebind 'w' and 'u' in
 +'eww-link-keymap' to it.
 +
 +** Ido
 +
 +*** The commands 'find-alternate-file-other-window',
 +'dired-other-window', 'dired-other-frame', and
 +'display-buffer-other-window' are now remapped to Ido equivalents if
 +Ido mode is active.
 +
 +** Images
 +
 +*** Images are automatically scaled before displaying based on the
 +'image-scaling-factor' variable (if Emacs supports scaling the images
 +in question).
 +
 +*** It's now possible to specify aspect-ratio preserving combinations
 +of :width/:max-height and :height/:max-width keywords.  In either
 +case, the "max" keywords win.  (Previously some combinations would,
 +depending on the aspect ratio of the image, just be ignored and in
 +other instances this would lead to the aspect ratio not being
 +preserved.)
 +
 +*** Images inserted with 'insert-image' and related functions get a
 +keymap put into the text properties (or overlays) that span the
 +image.  This keymap binds keystrokes for manipulating size and
 +rotation, as well as saving the image to a file.  These commands are
 +also available in 'image-mode'.
 +
 +*** A new library for creating and manipulating SVG images has been
 +added.  See the "(elisp) SVG Images" section in the ELisp reference
 +manual for details.
 +
 +*** New setf-able function to access and set image parameters is
 +provided: 'image-property'.
 +
 +*** New commands 'image-scroll-left' and 'image-scroll-right'
 +for 'image-mode' that complement 'image-scroll-up' and
 +'image-scroll-down': they have the same prefix arg behavior and stop
 +at image boundaries.
 +
 +** Image-Dired
 +
 +*** Now provides a minor mode 'image-dired-minor-mode' which replaces
 +the function 'image-dired-setup-dired-keybindings'.
 +
 +*** Thumbnail generation is now asynchronous.
 +The number of concurrent processes is limited by the variable
 +'image-dired-queue-active-limit'.
 +
 +*** 'image-dired-thumbnail-storage' has a new option 'standard-large'
 +for generating 256x256 thumbnails according to the Thumbnail Managing
 +Standard.
 +
 +*** Inherits movement keys from 'image-mode' for viewing full images.
 +This includes the usual char, line, and page movement commands.
 +
 +*** All the -options types have been changed to argument lists
 +instead of shell command strings.  This change affects
 +'image-dired-cmd-create-thumbnail-options',
 +'image-dired-cmd-create-temp-image-options',
 +'image-dired-cmd-rotate-thumbnail-options',
 +'image-dired-cmd-rotate-original-options',
 +'image-dired-cmd-write-exif-data-options',
 +'image-dired-cmd-read-exif-data-options', and introduces
 +'image-dired-cmd-pngnq-options', 'image-dired-cmd-pngcrush-options',
 +'image-dired-cmd-create-standard-thumbnail-options'.
 +
 +*** Recognizes more tools by default, including pngnq-s9 and OptiPNG.
 +
 +*** 'find-file' and related commands now work on thumbnails and
 +displayed images, providing a default argument of the original file name
 +via an addition to 'file-name-at-point-functions'.
 +
 +** The default 'Info-default-directory-list' no longer checks some obsolete
 +directory suffixes (gnu, gnu/lib, gnu/lib/emacs, emacs, lib, lib/emacs)
 +when searching for info directories.
 +
 +** The commands that add ChangeLog entries now prefer a VCS root directory
 +for the ChangeLog file, if none already exists.  Customize
 +'change-log-directory-files' to nil for the old behavior.
 +
 +** Support for non-string values of 'time-stamp-format' has been removed.
 +
 +** Message
 +
 +*** 'message-use-idna' now defaults to t (because Emacs comes with
 +built-in IDNA support now).
 +
 +*** When sending HTML messages with embedded images, and you have
 +exiftool installed, and you rotate images with EXIF data (i.e.,
 +JPEGs), the rotational information will be inserted into the outgoing
 +image in the message.  (The original image will not have its
 +orientation affected.)
 +
 +*** The 'message-valid-fqdn-regexp' variable has been removed, since
 +there are now top-level domains added all the time.  Message will no
 +longer warn about sending emails to top-level domains it hasn't heard
 +about.
 +
 +*** 'message-beginning-of-line' (bound to 'C-a') understands folded headers.
 +In 'visual-line-mode' it will look for the true beginning of a header
 +while in non-'visual-line-mode' it will move the point to the indented
 +header's value.
 +
 +** Package
 +
 +*** The new variable 'package-gnupghome-dir' has been added to control
 +where the GnuPG home directory (used for signature verification) is
 +located and whether GnuPG's option '--homedir' is used or not.
 +
 +*** Deleting a package no longer respects 'delete-by-moving-to-trash'.
 +
 +** Python
 +
 +*** The new variable 'python-indent-def-block-scale' has been added.
 +It controls the depth of indentation of arguments inside multi-line
 +function signatures.
 +
 +** Tramp
 +
 +*** The method part of remote file names is mandatory now.
 +A valid remote file name starts with "/method:host:" or
 +"/method:user@host:".
 +
 +*** The new pseudo method "-" is a marker for the default method.
 +"/-::" is the shortest remote file name then.
 +
 +*** The command 'tramp-change-syntax' allows you to choose an
 +alternative remote file name syntax.
 +
 +*** New connection method "sg", which supports editing files under a
 +different group ID.
 +
 +*** New connection method "doas" for OpenBSD hosts.
 +
 +*** New connection method "gdrive", which allows access to Google
 +Drive onsite repositories.
 +
 +*** Gateway methods in Tramp have been removed.
 +Instead, the Tramp manual documents how to configure ssh and PuTTY
 +accordingly.
 +
 +*** Setting the "ENV" environment variable in
 +'tramp-remote-process-environment' enables reading of shell
 +initialization files.
 +
 +*** Tramp is able now to send SIGINT to remote asynchronous processes.
 +
 +*** Variable 'tramp-completion-mode' is obsoleted.
 +
 +** 'auto-revert-use-notify' is set back to t in 'global-auto-revert-mode'.
 +
 +** JS mode
 +
 +*** JS mode now sets 'comment-multi-line' to t.
 +
 +*** New variable 'js-indent-align-list-continuation', when set to nil,
 +will not align continuations of bracketed lists, but will indent them
 +by the fixed width 'js-indent-level'.
 +
 +** CSS mode
 +
 +*** Support for completing attribute values, at-rules, bang-rules,
 +HTML tags, classes and IDs using the 'completion-at-point' command.
 +Completion candidates for HTML classes and IDs are retrieved from open
 +HTML mode buffers.
 +
 +*** CSS mode now binds 'C-h S' to a function that will show
 +information about a CSS construct (an at-rule, property, pseudo-class,
 +pseudo-element, with the default being guessed from context).  By
 +default the information is looked up on the Mozilla Developer Network,
 +but this can be customized using 'css-lookup-url-format'.
 +
 +*** CSS colors are fontified using the color they represent as the
 +background.  For instance, #ff0000 would be fontified with a red
 +background.
 +
 +** Emacs now supports character name escape sequences in character and
 +string literals.  The syntax variants '\N{character name}' and
 +'\N{U+code}' are supported.
 +
 +** Prog mode has some support for multi-mode indentation.
 +This allows better indentation support in modes that support multiple
 +programming languages in the same buffer, like literate programming
 +environments or ANTLR programs with embedded Python code.
 +
 +A major mode can provide indentation context for a sub-mode.  To
 +support this, modes should use 'prog-first-column' instead of a
 +literal zero and avoid calling 'widen' in their indentation functions.
 +See the node "(elisp) Mode-Specific Indent" in the ELisp manual for
 +more details.
 +
 +** ERC
 +
 +*** New variable 'erc-default-port-tls' used to connect to TLS IRC
 +servers.
 +
 +** URL
 +
 +*** The new function 'url-cookie-delete-cookie' can be used to
 +programmatically delete all cookies, or cookies from a specific
 +domain.
 +
 +*** 'url-retrieve-synchronously' now takes an optional timeout parameter.
 +
 +*** The URL package now supports HTTPS over proxies supporting CONNECT.
 +
 +*** 'url-user-agent' now defaults to 'default', and the User-Agent
 +string is computed dynamically based on 'url-privacy-level'.
 +
 +** VC and related modes
 +
 +*** 'vc-dir-mode' now binds 'vc-log-outgoing' to 'O'; and has various
 +branch-related commands on a keymap bound to 'B'.
 +
 +*** 'vc-region-history' is now bound to 'C-x v h', replacing the older
 +'vc-insert-headers' binding.
 +
 +*** New user option 'vc-git-print-log-follow' to follow renames in Git logs
 +for a single file.
 +
 +** CC mode
 +
 +*** Opening a .h file will turn C or C++ mode depending on language used.
 +This is done with the help of the 'c-or-c++-mode' function, which
 +analyzes buffer contents to infer whether it's a C or C++ source file.
 +
 +** New option 'cpp-message-min-time-interval' to allow user control
 +of progress messages in cpp.el.
 +
 +** New DNS mode command 'dns-mode-ipv6-to-nibbles' to convert IPv6 addresses
 +to a format suitable for reverse lookup zone files.
 +
 +** Ispell
 +
 +*** Enchant is now supported as a spell-checker.
 +Enchant is a meta-spell-checker that uses providers such as Hunspell
 +to do the actual checking.  With it, users can use spell-checkers not
 +directly supported by Emacs, such as Voikko, Hspell and AppleSpell,
 +more easily share personal word-lists with other programs, and
 +configure different spelling-checkers for different languages.
 +(Version 2.1.0 or later of Enchant is required.)
 +
 +** Flymake
 +
 +*** Flymake has been completely redesigned.
 +Flymake now annotates arbitrary buffer regions, not just lines.  It
 +supports arbitrary diagnostic types, not just errors and warnings (see
 +variable 'flymake-diagnostic-types-alist').
 +
 +It also supports multiple simultaneous backends, meaning that you can
 +check your buffer from different perspectives (see variable
 +'flymake-diagnostic-functions').  Backends for Emacs Lisp mode are
 +provided.
 +
 +The old Flymake behavior is preserved in the so-called "legacy
 +backend", which has been updated to benefit from the new UI features.
 +
 +** Term
 +
 +*** 'term-char-mode' now makes its buffer read-only.
 +The buffer is made read-only to prevent changes from being made by
 +anything other than the process filter; and movements of point away
 +from the process mark are counter-acted so that the cursor is in the
 +correct position after each command.  This is needed to avoid states
 +which are inconsistent with the state of the terminal understood by
 +the inferior process.
 +
 +New user options 'term-char-mode-buffer-read-only' and
 +'term-char-mode-point-at-process-mark' control these behaviors, and
 +are non-nil by default.  Customize these options to nil if you want
 +the previous behavior.
 +
 +** Xref
 +
 +*** When an *xref* buffer is needed, 'TAB' quits and jumps to an xref.
 +A new command 'xref-quit-and-goto-xref', bound to 'TAB' in *xref*
 +buffers, quits the window before jumping to the destination.  In many
 +situations, the intended window configuration is restored, just as if
 +the *xref* buffer hadn't been necessary in the first place.
 +
 +\f
 +* New Modes and Packages in Emacs 26.1
 +
 +** New Elisp data-structure library 'radix-tree'.
 +
 +** New library 'xdg' with utilities for some XDG standards and specs.
 +
 +** HTML
 +
 +*** A new submode of 'html-mode', 'mhtml-mode', is now the default
 +mode for *.html files.  This mode handles indentation,
 +fontification, and commenting for embedded JavaScript and CSS.
 +
 +** New mode 'conf-toml-mode' is a sub-mode of 'conf-mode', specialized
 +for editing TOML files.
 +
 +** New mode 'conf-desktop-mode' is a sub-mode of 'conf-unix-mode',
 +specialized for editing freedesktop.org desktop entries.
 +
 +** New minor mode 'pixel-scroll-mode' provides smooth pixel-level scrolling.
 +
 +** New major mode 'less-css-mode' (a minor variant of 'css-mode') for
 +editing Less files.
 +
 +** New package 'auth-source-pass' integrates 'auth-source' with the
 +password manager password-store (http://passwordstore.org).
 +
 +\f
 +* Incompatible Lisp Changes in Emacs 26.1
 +
 +** 'password-data' is now a hash-table so that 'password-read' can use
 +any object for the 'key' argument.
 +
 +** Command 'dired-mark-extension' now automatically prepends a '.' to the
 +extension when not present.  The new command 'dired-mark-suffix' behaves
 +similarly but it doesn't prepend a '.'.
 +
 +** Certain cond/pcase/cl-case forms are now compiled using a faster jump
 +table implementation.  This uses a new bytecode op 'switch', which
 +isn't compatible with previous Emacs versions.  This functionality can
 +be disabled by setting 'byte-compile-cond-use-jump-table' to nil.
 +
 +** If 'comment-auto-fill-only-comments' is non-nil, 'auto-fill-function'
 +is now called only if either no comment syntax is defined for the
 +current buffer or the self-insertion takes place within a comment.
 +
 +** The alist 'ucs-names' is now a hash table.
 +
 +** 'if-let' and 'when-let' now support binding lists as defined by the
 +SRFI-2 (Scheme Request for Implementation 2).
 +
 +** 'C-up', 'C-down', 'C-left' and 'C-right' are now defined in term
 +mode to send the same escape sequences that xterm does.  This makes
 +things like 'forward-word' in readline work.
 +
 +** Customizable variable 'query-replace-from-to-separator'
 +now doesn't propertize the string value of the separator.
 +Instead, text properties are added by 'query-replace-read-from'.
 +Additionally, the new nil value restores pre-24.5 behavior
 +of not providing replacement pairs via the history.
 +
 +** Some obsolete functions, variables, and faces have been removed:
 +
 +*** 'make-variable-frame-local'.  Variables cannot be frame-local any more.
 +
 +*** From subr.el: 'window-dot', 'set-window-dot', 'read-input',
 +'show-buffer', 'eval-current-buffer', 'string-to-int'.
 +
 +*** 'icomplete-prospects-length'.
 +
 +*** All the default-FOO variables that hold the default value of the
 +FOO variable.  Use 'default-value' and 'setq-default' to access and
 +change FOO, respectively.  The exhaustive list of removed variables is:
 +'default-mode-line-format', 'default-header-line-format',
 +'default-line-spacing', 'default-abbrev-mode', 'default-ctl-arrow',
 +'default-truncate-lines', 'default-left-margin', 'default-tab-width',
 +'default-case-fold-search', 'default-left-margin-width',
 +'default-right-margin-width', 'default-left-fringe-width',
 +'default-right-fringe-width', 'default-fringes-outside-margins',
 +'default-scroll-bar-width', 'default-vertical-scroll-bar',
 +'default-indicate-empty-lines', 'default-indicate-buffer-boundaries',
 +'default-fringe-indicator-alist', 'default-fringe-cursor-alist',
 +'default-scroll-up-aggressively', 'default-scroll-down-aggressively',
 +'default-fill-column', 'default-cursor-type',
 +'default-cursor-in-non-selected-windows',
 +'default-buffer-file-coding-system', 'default-major-mode', and
 +'default-enable-multibyte-characters'.
 +
 +*** Many variables obsoleted in 22.1 referring to face symbols.
 +
 +** The variable 'text-quoting-style' is now a customizable option.
 +It controls whether to and how to translate ASCII quotes in messages
 +and help output.  Its possible values and their semantics remain
 +unchanged from Emacs 25.  In particular, when this variable's value is
 +'grave', all quotes in formats are output as-is.
 +
 +** Functions like 'check-declare-file' and 'check-declare-directory'
 +now generate less chatter and more-compact diagnostics.  The auxiliary
 +function 'check-declare-errmsg' has been removed.
 +
 +** The regular expression character class '[:blank:]' now matches
 +Unicode horizontal whitespace as defined in the Unicode Technical
 +Standard #18.  If you only want to match space and tab, use '[ \t]'
 +instead.
 +
 +** 'min' and 'max' no longer round their results.
 +Formerly, they returned a floating-point value if any argument was
 +floating-point, which was sometimes numerically incorrect.  For
 +example, on a 64-bit host (max 1e16 10000000000000001) now returns its
 +second argument instead of its first.
 +
 +** The variable 'old-style-backquotes' has been made internal and
 +renamed to 'lread--old-style-backquotes'.  No user code should use
 +this variable.
 +
 +** 'default-file-name-coding-system' now defaults to a coding system
 +that does not process CRLF.  For example, it defaults to 'utf-8-unix'
 +instead of to 'utf-8'.  Before this change, Emacs would sometimes
 +mishandle file names containing these control characters.
 +
 +** 'file-attributes', 'file-symlink-p' and 'make-symbolic-link' no
 +longer quietly mutate the target of a local symbolic link, so that
 +Emacs can access and copy them reliably regardless of their contents.
 +The following changes are involved.
 +
 +*** 'file-attributes' and 'file-symlink-p' no longer prepend "/:" to
 +symbolic links whose targets begin with "/" and contain ":".  For
 +example, if a symbolic link "x" has a target "/y:z:", '(file-symlink-p
 +"x")' now returns "/y:z:" rather than "/:/y:z:".
 +
 +*** 'make-symbolic-link' no longer looks for file name handlers of
 +target when creating a symbolic link.  For example,
 +'(make-symbolic-link "/y:z:" "x")' now creates a symbolic link to
 +"/y:z:" instead of failing.
 +
 +*** 'make-symbolic-link' removes the remote part of a link target if
 +target and newname have the same remote part.  For example,
 +'(make-symbolic-link "/x:y:a" "/x:y:b")' creates a link with the
 +literal string "a"; and '(make-symbolic-link "/x:y:a" "/x:z:b")'
 +creates a link with the literal string "/x:y:a" instead of failing.
 +
 +*** 'make-symbolic-link' now expands a link target with leading "~"
 +only when the optional third arg is an integer, as when invoked
 +interactively.  For example, '(make-symbolic-link "~y" "x")' now
 +creates a link with target the literal string "~y"; to get the old
 +behavior, use '(make-symbolic-link (expand-file-name "~y") "x")'.  To
 +avoid this expansion in interactive use, you can now prefix the link
 +target with "/:".  For example, '(make-symbolic-link "/:~y" "x" 1)'
 +now creates a link to literal "~y".
 +
 +** 'file-truename' returns a quoted file name if the target of a
 +symbolic link has remote file name syntax.
 +
 +** Module functions are now implemented slightly differently; in
 +particular, the function 'internal--module-call' has been removed.
 +Code that depends on undocumented internals of the module system might
 +break.
 +
 +** The argument LOCKNAME of 'write-region' is propagated to file name
 +handlers now.
 +
 +** When built against recent versions of GTK+, Emacs always uses
 +gtk_window_move for moving frames and ignores the value of the
 +variable 'x-gtk-use-window-move'.  The variable is now obsolete.
 +
 +** Several functions that create or rename files now treat their
 +destination argument specially only when it is a directory name, i.e.,
 +when it ends in '/' on GNU and other POSIX-like systems.  When the
 +destination argument D of one of these functions is an existing
 +directory and the intent is to act on an entry in that directory, D
 +should now be a directory name.  For example, (rename-file "e" "f/")
 +renames to 'f/e'.  Although this formerly happened sometimes even when
 +D was not a directory name, as in (rename-file "e" "f") where 'f'
 +happened to be a directory, the old behavior often contradicted the
 +documentation and had inherent races that led to security holes.  A
 +call like (rename-file C D) that used the old, undocumented behavior
 +can be written as (rename-file C (file-name-as-directory D)), a
 +formulation portable to both older and newer versions of Emacs.
 +Affected functions include 'add-name-to-file', 'copy-directory',
 +'copy-file', 'format-write-file', 'gnus-copy-file',
 +'make-symbolic-link', 'rename-file', 'thumbs-rename-images', and
 +'write-file'.
 +
 +** The list returned by 'overlays-at' is now in decreasing priority order.
 +The documentation of this function always said the order should be
 +that of decreasing priority, if the 2nd argument of the function is
 +non-nil, but the code returned the list in the increasing order of
 +priority instead.  Now the code does what the documentation says it
 +should do.
 +
 +** 'format' now avoids allocating a new string in more cases.
 +'format' was previously documented to return a newly-allocated string,
 +but this documentation was not correct, as (eq x (format x)) returned
 +t when x was the empty string.  'format' is no longer documented to
 +return a newly-allocated string, and the implementation now takes
 +advantage of the doc change to avoid making copies of strings in
 +common cases like (format "foo") and (format "%s" "foo").
 +
 +** The function 'eldoc-message' now accepts a single argument.
 +Programs that called it with multiple arguments before should pass
 +them through 'format' first.  Even that is discouraged: for ElDoc
 +support, you should set 'eldoc-documentation-function' instead of
 +calling 'eldoc-message' directly.
 +
 +** Using '&rest' or '&optional' incorrectly is now an error.
 +For example giving '&optional' without a following variable, or
 +passing '&optional' multiple times:
 +
 +    (defun foo (&optional &rest x))
 +    (defun bar (&optional &optional x))
 +
 +Previously, Emacs would just ignore the extra keyword, or give
 +incorrect results in certain cases.
 +
 +** The pinentry.el library has been removed.
 +That package (and the corresponding change in GnuPG and pinentry)
 +was intended to provide a way to input passphrase through Emacs with
 +GnuPG 2.0.  However, the change to support that was only implemented
 +in GnuPG >= 2.1 and didn't get backported to GnuPG 2.0.  And with
 +GnuPG 2.1 and later, pinentry.el is not needed at all.  So the
 +library was useless, and we removed it.  GnuPG 2.0 is no longer
 +supported by the upstream project.
 +
 +To adapt to the change, you may need to set 'epa-pinentry-mode' to the
 +symbol 'loopback'.  Alternatively, leave 'epa-pinentry-mode' at its
 +default value of nil, and remove the 'allow-emacs-pinentry' setting
 +from your 'gpg-agent.conf' configuration file, usually found in the
 +'~/.gnupg' directory.
 +
 +Note that previously, it was said that passphrase input through
 +minibuffer would be much less secure than other graphical pinentry
 +programs.  However, these days the difference is insignificant: the
 +'read-password' function sufficiently protects input from leakage to
 +message logs.  Emacs still doesn't use secure memory to protect
 +passphrases, but it was also removed from other pinentry programs as
 +the attack is unrealistic on modern computer systems which don't
 +utilize swap memory usually.
 +
 +** The function 'display-buffer-in-major-side-window' no longer exists.
 +It has been renamed as internal function 'window--make-major-side-window',
 +however applications should instead call 'display-buffer-in-side-window'
 +(passing the SIDE and SLOT parameters as elements of ALIST).  This approach
 +is backwards-compatible with versions of Emacs in which the old function
 +exists.  See the node "Displaying Buffers in Side Windows" in the ELisp
 +manual for more details.
 +\f
 +* Lisp Changes in Emacs 26.1
 +
 +** The function 'assoc' now takes an optional third argument TESTFN.
 +This argument, when non-nil, is used for comparison instead of
 +'equal'.
 +
 +** New optional argument TESTFN in 'alist-get', 'map-elt' and 'map-put'.
 +If non-nil, the argument specifies a function to use for comparison,
 +instead of, respectively, 'assq' and 'eql'.
 +
 +** New function 'seq-set-equal-p' to check if SEQUENCE1 and SEQUENCE2
 +contain the same elements, regardless of the order.
 +
 +** The new function 'mapbacktrace' applies a function to all frames of
 +the current stack trace.
 +
 +** The new function 'file-name-case-insensitive-p' tests whether a
 +given file is on a case-insensitive filesystem.
 +
 +** Several accessors for the value returned by 'file-attributes'
 +have been added.  They are: 'file-attribute-type',
 +'file-attribute-link-number', 'file-attribute-user-id',
 +'file-attribute-group-id', 'file-attribute-access-time',
 +'file-attribute-modification-time',
 +'file-attribute-status-change-time', 'file-attribute-size',
 +'file-attribute-modes', 'file-attribute-inode-number',
 +'file-attribute-device-number' and 'file-attribute-collect'.
 +
 +** The new function 'buffer-hash' computes a fast, non-consing hash of
 +a buffer's contents.
 +
 +** 'interrupt-process' now consults the list 'interrupt-process-functions',
 +to determine which function has to be called in order to deliver the
 +SIGINT signal.  This allows Tramp to send the SIGINT signal to remote
 +asynchronous processes.  The hitherto existing implementation has been
 +moved to 'internal-default-interrupt-process'.
 +
 +** The new function 'read-multiple-choice' prompts for multiple-choice
 +questions, with a handy way to display help texts.
 +
 +** 'comment-indent-function' values may now return a cons to specify a
 +range of indentation.
 +
 +** New optional argument TEXT in 'make-temp-file'.
 +
 +** New function 'define-symbol-prop'.
 +
 +** New function 'secure-hash-algorithms' to list the algorithms that
 +'secure-hash' supports.
 +See the node "(elisp) Checksum/Hash" in the ELisp manual for details.
 +
 +** Emacs now exposes the GnuTLS cryptographic API with the functions
 +'gnutls-macs' and 'gnutls-hash-mac'; 'gnutls-digests' and
 +'gnutls-hash-digest'; 'gnutls-ciphers' and 'gnutls-symmetric-encrypt'
 +and 'gnutls-symmetric-decrypt'.
 +See the node "(elisp) GnuTLS Cryptography" in the ELisp manual for details.
 +
 +** The function 'gnutls-available-p' now returns a list of capabilities
 +supported by the GnuTLS library used by Emacs.
 +
 +** Emacs now supports records for user-defined types, via the new
 +functions 'make-record', 'record', and 'recordp'.  Records are now
 +used internally to represent cl-defstruct and defclass instances, for
 +example.
 +
 +If your program defines new record types, you should use
 +package-naming conventions for naming those types.  This is so any
 +potential conflicts with other types are avoided.
 +
 +** 'save-some-buffers' now uses 'save-some-buffers-default-predicate'
 +to decide which buffers to ask about, if the PRED argument is nil.
 +The default value of 'save-some-buffers-default-predicate' is nil,
 +which means ask about all file-visiting buffers.
 +
 +** string-(to|as|make)-(uni|multi)byte are now declared obsolete.
 +
 +** New variable 'while-no-input-ignore-events' which allow
 +setting which special events 'while-no-input' should ignore.
 +It is a list of symbols.
 +
 +** New function 'undo-amalgamate-change-group' to get rid of
 +undo-boundaries between two states.
 +
 +** New var 'definition-prefixes' is a hash table mapping prefixes to
 +the files where corresponding definitions can be found.  This can be
 +used to fetch definitions that are not yet loaded, for example for
 +'C-h f'.
 +
 +** New var 'syntax-ppss-table' to control the syntax-table used in
 +'syntax-ppss'.
 +
 +** 'define-derived-mode' can now specify an :after-hook form, which
 +gets evaluated after the new mode's hook has run.  This can be used to
 +incorporate configuration changes made in the mode hook into the
 +mode's setup.
 +
 +** Autoload files are now generated without timestamps.
 +Set 'autoload-timestamps' to a non-nil value to get timestamps in
 +autoload files.
 +
 +** 'gnutls-boot' now takes a parameter ':complete-negotiation' that
 +says that negotiation should complete even on non-blocking sockets.
 +
 +** There is now a new variable 'flyspell-sort-corrections-function'
 +that allows changing the way corrections are sorted.
 +
 +** The new command 'fortune-message' has been added, which displays
 +fortunes in the echo area.
 +
 +** New function 'func-arity' returns information about the argument list
 +of an arbitrary function.  This generalizes 'subr-arity' for functions
 +that are not built-in primitives.  We recommend using this new
 +function instead of 'subr-arity'.
 +
 +** New function 'region-bounds' can be used in the interactive spec
 +to provide region boundaries (for rectangular regions more than one)
 +to an interactively callable function as a single argument instead of
 +two separate arguments 'region-beginning' and 'region-end'.
 +
 +** 'parse-partial-sexp' state has a new element.
 +Element 10 is non-nil when the last character scanned might be the
 +first character of a two character construct, i.e., a comment
 +delimiter or escaped character.  Its value is the syntax of that last
 +character.
 +
 +** 'parse-partial-sexp's state, element 9, has now been confirmed as
 +permanent and documented, and may be used by Lisp programs.  Its value
 +is a list of currently open parenthesis positions, starting with the
 +outermost parenthesis.
 +
 +** 'read-color' will now display the color names using the color itself
 +as the background color.
 +
 +** The function 'redirect-debugging-output' now works on platforms
 +other than GNU/Linux.
 +
 +** The new function 'string-version-lessp' compares strings by
 +interpreting consecutive runs of numerical characters as numbers, and
 +compares their numerical values.  According to this predicate,
 +"foo2.png" is smaller than "foo12.png".
 +
 +** Numeric comparisons and 'logb' no longer return incorrect answers
 +due to internal rounding errors.  For example, '(< most-positive-fixnum
 +(+ 1.0 most-positive-fixnum))' now correctly returns t on 64-bit hosts.
 +
 +** The functions 'ffloor', 'fceiling', 'ftruncate' and 'fround' now
 +accept only floating-point arguments, as per their documentation.
 +Formerly, they quietly accepted integer arguments and sometimes
 +returned nonsensical answers, e.g., '(< N (ffloor N))' could return t.
 +
 +** On hosts like GNU/Linux x86-64 where a 'long double' fraction
 +contains at least EMACS_INT_WIDTH - 3 bits, 'format' no longer returns
 +incorrect answers due to internal rounding errors when formatting
 +Emacs integers with '%e', '%f', or '%g' conversions.  For example, on
 +these hosts '(eql N (string-to-number (format "%.0f" N)))' now returns
 +t for all Emacs integers N.
 +
 +** Calls that accept floating-point integers (for use on hosts with
 +limited integer range) now signal an error if arguments are not
 +integral.  For example '(decode-char 'ascii 0.5)' now signals an
 +error.
 +
 +** Functions 'string-trim-left', 'string-trim-right' and 'string-trim'
 +now accept optional arguments which specify the regexp of a substring
 +to trim.
 +
 +** The new function 'char-from-name' converts a Unicode name string
 +to the corresponding character code.
 +
 +** New functions 'sxhash-eq' and 'sxhash-eql' return hash codes of a
 +Lisp object suitable for use with 'eq' and 'eql' correspondingly.  If
 +two objects are 'eq' ('eql'), then the result of 'sxhash-eq'
 +('sxhash-eql') on them will be the same.
 +
 +** Function 'sxhash' has been renamed to 'sxhash-equal' for
 +consistency with the new functions.  For compatibility, 'sxhash'
 +remains as an alias to 'sxhash-equal'.
 +
 +** 'make-hash-table' now defaults to a rehash threshold of 0.8125
 +instead of 0.8, to avoid rounding glitches.
 +
 +** New function 'add-variable-watcher' can be used to call a function
 +when a symbol's value is changed.  This is used to implement the new
 +debugger command 'debug-on-variable-change'.
 +
 +** New variable 'print-escape-control-characters' causes 'prin1' and
 +'print' to output control characters as backslash sequences.
 +
 +** Time conversion functions that accept a time zone rule argument now
 +allow it to be OFFSET or a list (OFFSET ABBR), where the integer
 +OFFSET is a count of seconds east of Universal Time, and the string
 +ABBR is a time zone abbreviation.  The affected functions are
 +'current-time-string', 'current-time-zone', 'decode-time',
 +'format-time-string', and 'set-time-zone-rule'.
 +
 +** 'format-time-string' now formats '%q' to the calendar quarter.
 +
 +** New built-in function 'mapcan'.
 +It avoids unnecessary consing (and garbage collection).
 +
 +** 'car' and 'cdr' compositions 'cXXXr' and 'cXXXXr' are now part of Elisp.
 +
 +** 'gensym' is now part of Elisp.
 +
 +** Low-level list functions like 'length' and 'member' now do a better
 +job of signaling list cycles instead of looping indefinitely.
 +
 +** The new functions 'make-nearby-temp-file' and 'temporary-file-directory'
 +can be used for creation of temporary files on remote or mounted directories.
 +
 +** On GNU platforms when operating on a local file, 'file-attributes'
 +no longer suffers from a race when called while another process is
 +altering the filesystem.  On non-GNU platforms 'file-attributes'
 +attempts to detect the race, and returns nil if it does so.
 +
 +** The new function 'file-local-name' can be used to specify arguments
 +of remote processes.
 +
 +** The new functions 'file-name-quote', 'file-name-unquote' and
 +'file-name-quoted-p' can be used to quote / unquote file names with
 +the prefix "/:".
 +
 +** The new error 'file-missing', a subcategory of 'file-error', is now
 +signaled instead of 'file-error' if a file operation acts on a file
 +that does not exist.
 +
 +** The function 'delete-directory' no longer signals an error when
 +operating recursively and when some other process deletes the directory
 +or its files before 'delete-directory' gets to them.
 +
 +** New error type 'user-search-failed' like 'search-failed' but
 +avoids debugger like 'user-error'.
 +
 +** The function 'line-number-at-pos' now takes a second optional
 +argument 'absolute'.  If this parameter is nil, the default, this
 +function keeps on returning the line number taking potential narrowing
 +into account.  If this parameter is non-nil, the function ignores
 +narrowing and returns the absolute line number.
 +
 +** The function 'color-distance' now takes a second optional argument
 +'metric'.  When non-nil, it should be a function of two arguments that
 +accepts two colors and returns a number.
 +
 +** Changes in Frame and Window Handling
 +
 +*** Resizing a frame no longer runs 'window-configuration-change-hook'.
 +'window-size-change-functions' should be used instead.
 +
 +*** The new function 'frame-size-changed-p' can tell whether a frame has
 +been resized since the last time 'window-size-change-functions' has been
 +run.
 +
 +*** The function 'frame-geometry' now also returns the width of a
 +frame's outer border.
 +
 +*** New frame parameters and changed semantics for older ones:
 +
 +**** 'z-group' positions a frame above or below all others.
 +
 +**** 'min-width' and 'min-height' specify the absolute minimum size of a
 +frame.
 +
 +**** 'parent-frame' makes a frame the child frame of another Emacs
 +frame.  The section "(elisp) Child Frames" in the ELisp manual
 +describes the intrinsics of that relationship.
 +
 +**** 'delete-before' triggers deletion of one frame before that of
 +another.
 +
 +**** 'mouse-wheel-frame' specifies another frame whose windows shall be
 +scrolled instead.
 +
 +**** 'no-other-frame' has 'next-frame' and 'previous-frame' skip this
 +frame.
 +
 +**** 'skip-taskbar' removes a frame's icon from the taskbar and has
 +'Alt-<TAB>' skip this frame.
 +
 +**** 'no-focus-on-map' avoids that a frame gets input focus when mapped.
 +
 +**** 'no-accept-focus' means that a frame does not want to get input
 +focus via the mouse.
 +
 +**** 'undecorated' removes the window manager decorations from a frame.
 +
 +**** 'override-redirect' tells the window manager to disregard this
 +frame.
 +
 +**** 'width' and 'height' now allow the specification of pixel values
 +and ratios.
 +
 +**** 'left' and 'top' now allow the specification of ratios.
 +
 +**** 'keep-ratio' preserves size and position of child frames when their
 +parent frame is resized.
 +
 +**** 'no-special-glyphs' suppresses display of truncation and
 +continuation glyphs in a frame.
 +
 +**** 'auto-hide-function' and 'minibuffer-exit' handle auto hiding of
 +frames and exiting from minibuffer individually.
 +
 +**** 'fit-frame-to-buffer-margins' and 'fit-frame-to-buffer-sizes'
 +handle fitting a frame to its buffer individually.
 +
 +**** 'drag-internal-border', 'drag-with-header-line',
 +'drag-with-mode-line', 'snap-width', 'top-visible' and 'bottom-visible'
 +allow dragging and resizing frames with the mouse.
 +
 +**** 'minibuffer' is now set to the default minibuffer window when
 +initially specified as nil and is not reset to nil when initially
 +specifying a minibuffer window.
 +
 +*** The new function 'frame-list-z-order' returns a list of all frames
 +in Z (stacking) order.
 +
 +*** The function 'x-focus-frame' optionally tries to not activate its
 +frame.
 +
 +*** The variable 'focus-follows-mouse' has a third meaningful value
 +'auto-raise' to indicate that the window manager automatically raises a
 +frame when the mouse pointer enters it.
 +
 +*** The new function 'frame-restack' puts a frame above or below
 +another on the display.
 +
 +*** The new face 'internal-border' specifies the background of a frame's
 +internal border.
 +
 +*** The NORECORD argument of 'select-window' now has a meaningful value
 +'mark-for-redisplay' which is like any other non-nil value but marks
 +WINDOW for redisplay.
 +
 +*** Support for side windows is now official.  The display action
 +function 'display-buffer-in-side-window' will display its buffer in a
 +side window.  Functions for toggling all side windows on a frame,
 +changing and reversing the layout of side windows and returning the
 +main (major non-side) window of a frame are provided.  For details
 +consult the section "(elisp) Side Windows" in the ELisp manual.
 +
 +*** Support for atomic windows - rectangular compositions of windows
 +treated by 'split-window', 'delete-window' and 'delete-other-windows'
 +like a single live window - is now official.  For details consult the
 +section "(elisp) Atomic Windows" in the ELisp manual.
 +
 +*** New 'display-buffer' alist entry 'window-parameters' allows the
 +assignment of window parameters to the window used for displaying the
 +buffer.
 +
 +*** New function 'display-buffer-reuse-mode-window' is an action function
 +suitable for use in 'display-buffer-alist'.  For example, to avoid
 +creating a new window when opening man pages when there's already one,
 +use
 +
 +(add-to-list 'display-buffer-alist
 +     '("\\`\\*Man .*\\*\\'" .
 +       (display-buffer-reuse-mode-window
 +        (inhibit-same-window . nil)
 +        (mode . Man-mode))))
 +
 +*** New window parameter 'no-delete-other-windows' prevents that
 +its window gets deleted by 'delete-other-windows'.
 +
 +*** New window parameters 'mode-line-format' and 'header-line-format'
 +allow the buffer-local formats for this window to be overridden.
 +
 +*** New command 'window-swap-states' swaps the states of two live
 +windows.
 +
 +*** New functions 'window-pixel-width-before-size-change' and
 +'window-pixel-height-before-size-change' support detecting which
 +window changed size when 'window-size-change-functions' are run.
 +
 +*** The new function 'window-lines-pixel-dimensions' returns the pixel
 +dimensions of a window's text lines.
 +
 +*** The new function 'window-largest-empty-rectangle' returns the
 +dimensions of the largest rectangular area not occupying any text in a
 +window's body.
 +
 +*** The semantics of 'mouse-autoselect-window' has changed slightly.
 +For details see the section "(elisp) Mouse Window Auto-selection" in
 +the ELisp manual.
 +
 +*** 'select-frame-by-name' now may return a frame on another display
 +if it does not find a suitable one on the current display.
 +
 +** 'tcl-auto-fill-mode' is now declared obsolete.
 +Its functionality can be replicated simply by setting
 +'comment-auto-fill-only-comments'.
 +
 +** New pcase pattern 'rx' to match against an rx-style regular expression.
 +For details, see the doc string of 'rx--pcase-macroexpander'.
 +
 +** New functions to set region from secondary selection and vice versa.
 +The new functions 'secondary-selection-to-region' and
 +'secondary-selection-from-region' let you set the beginning and the
 +end of the region from those of the secondary selection and vice
 +versa.
 +
 +** New function 'lgstring-remove-glyph' can be used to modify a
 +gstring returned by the underlying layout engine (e.g. m17n-flt,
 +uniscribe).
 +
 +\f
 +* Changes in Emacs 26.1 on Non-Free Operating Systems
 +
 +** Intercepting hotkeys on Windows 7 and later now works better.
 +The new keyboard hooking code properly grabs system hotkeys such as
 +'Win-*' and 'Alt-TAB', in a way that Emacs can get at them before the
 +system.  This makes the 'w32-register-hot-key' functionality work
 +again on all versions of MS-Windows starting with Windows 7.  On
 +Windows NT and later you can now register any hotkey combination.  (On
 +Windows 9X, the previous limitations, spelled out in the Emacs manual,
 +still apply.)
 +
 +** 'convert-standard-filename' no longer mirrors slashes on MS-Windows.
 +Previously, on MS-Windows this function converted slash characters in
 +file names into backslashes.  It no longer does that.  If your Lisp
 +program used 'convert-standard-filename' to prepare file names to be
 +passed to subprocesses (which is not the recommended usage of that
 +function), you will now have to mirror slashes in your application
 +code.  One possible way is this:
 +
 +         (let ((start 0))
 +           (while (string-match "/" file-name start)
 +             (aset file-name (match-beginning 0) ?\\)
 +             (setq start (match-end 0))))
 +
 +** GUI sessions on MS-Windows now treat SIGINT like Posix platforms do.
 +The effect of delivering a Ctrl-C (SIGINT) signal to a GUI Emacs on
 +MS-Windows is now the same as on Posix platforms -- Emacs saves the
 +session and exits.  In particular, this will happen if you start
 +emacs.exe from the Windows shell, then type Ctrl-C into that shell's
 +window.
 +
 +** 'signal-process' supports SIGTRAP on Windows XP and later.
 +The 'kill' emulation on Windows now maps SIGTRAP to a call to the
 +'DebugBreakProcess' API.  This causes the receiving process to break
 +execution and return control to the debugger.  If no debugger is
 +attached to the receiving process, the call is typically ignored.
 +This is in contrast to the default action on POSIX Systems, where it
 +causes the receiving process to terminate with a core dump if no
 +debugger has been attached to it.
 +
 +** 'set-mouse-position' and 'set-mouse-absolute-pixel-position' work
 +on macOS.
 +
 +** Emacs can now be run as a GUI application from the command line on
 +macOS.
 +
 +** 'ns-appearance' and 'ns-transparent-titlebar' change the appearance
 +of frame decorations on macOS 10.9+.
 +
 +** 'ns-use-thin-smoothing' enables thin font smoothing on macOS 10.8+.
 +
 +** 'process-attributes' on Darwin systems now returns more information.
 +
 +** Mousewheel and trackpad scrolling on macOS 10.7+ now behaves more
 +like the macOS default.  The new variables 'ns-mwheel-line-height',
 +'ns-use-mwheel-acceleration' and 'ns-use-mwheel-momentum' can be used
 +to customize the behavior.
 +
 +\f
 +----------------------------------------------------------------------
 +This file is part of GNU Emacs.
 +
 +GNU Emacs is free software: you can redistribute it and/or modify
 +it under the terms of the GNU General Public License as published by
 +the Free Software Foundation, either version 3 of the License, or
 +(at your option) any later version.
 +
 +GNU Emacs is distributed in the hope that it will be useful,
 +but WITHOUT ANY WARRANTY; without even the implied warranty of
 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +GNU General Public License for more details.
 +
 +You should have received a copy of the GNU General Public License
 +along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
 +
 +\f
 +Local variables:
 +coding: utf-8
 +mode: outline
 +paragraph-separate: "[        \f]*$"
 +end:

diff --cc etc/PROBLEMS
Simple merge

diff --cc etc/emacs-buffer.gdb
Simple merge

diff --cc etc/enriched.txt
Simple merge

diff --cc etc/refcards/Makefile
Simple merge

diff --cc etc/refcards/cs-survival.tex
Simple merge

diff --cc etc/refcards/fr-survival.tex
Simple merge

diff --cc etc/refcards/ru-refcard.tex
index 0c4cfbe88fd02a5dafe08a76a5d3e888fe302110,d44a104f6ba47c6f375e0f67e8404701d96e2920..43c18d58e29592744d8583673e5cac32f0751fb9
--- 1/etc/refcards/ru-refcard.tex
--- 2/etc/refcards/ru-refcard.tex
+++ b/etc/refcards/ru-refcard.tex
@@@ -40,8 -40,8 +40,8 @@@
  \newlength{\ColThreeWidth}
  \setlength{\ColThreeWidth}{25mm}
  
 -\newcommand{\versionemacs}[0]{26} % version of Emacs this is for
 +\newcommand{\versionemacs}[0]{27} % version of Emacs this is for
- \newcommand{\cyear}[0]{2018}       % copyright year
+ \newcommand{\cyear}[0]{2019}       % copyright year
  
  \newcommand\shortcopyrightnotice[0]{\vskip 1ex plus 2 fill
    \centerline{\footnotesize \copyright\ \cyear\ Free Software Foundation, Inc.

diff --cc etc/refcards/sk-survival.tex
Simple merge

diff --cc etc/refcards/survival.tex
Simple merge

diff --cc etc/themes/adwaita-theme.el
Simple merge

diff --cc etc/themes/deeper-blue-theme.el
Simple merge

diff --cc etc/themes/dichromacy-theme.el
Simple merge

diff --cc etc/themes/leuven-theme.el
Simple merge

diff --cc etc/themes/light-blue-theme.el
Simple merge

diff --cc etc/themes/manoj-dark-theme.el
Simple merge

diff --cc etc/themes/misterioso-theme.el
Simple merge

diff --cc etc/themes/tango-dark-theme.el
Simple merge

diff --cc etc/themes/tango-theme.el
Simple merge

diff --cc etc/themes/tsdh-dark-theme.el
Simple merge

diff --cc etc/themes/tsdh-light-theme.el
Simple merge

diff --cc etc/themes/wheatgrass-theme.el
Simple merge

diff --cc etc/themes/whiteboard-theme.el
Simple merge

diff --cc etc/themes/wombat-theme.el
Simple merge

diff --cc lib-src/Makefile.in
Simple merge

diff --cc lib-src/ebrowse.c
Simple merge

diff --cc lib-src/emacsclient.c
Simple merge

diff --cc lib-src/etags.c
Simple merge

diff --cc lib-src/make-docfile.c
Simple merge

diff --cc lib-src/movemail.c
Simple merge

diff --cc lib-src/ntlib.c
Simple merge

diff --cc lib-src/profile.c
Simple merge

diff --cc lib/Makefile.in
Simple merge

diff --cc lib/acl-internal.c
Simple merge

diff --cc lib/acl-internal.h
Simple merge

diff --cc lib/acl_entries.c
Simple merge

diff --cc lib/binary-io.h
Simple merge

diff --cc lib/dosname.h
Simple merge

diff --cc lib/dtotimespec.c
Simple merge

diff --cc lib/dup2.c
Simple merge

diff --cc lib/errno.in.h
Simple merge

diff --cc lib/euidaccess.c
Simple merge

diff --cc lib/explicit_bzero.c
Simple merge

diff --cc lib/fcntl.c
Simple merge

diff --cc lib/fcntl.in.h
Simple merge

diff --cc lib/fpending.c
Simple merge

diff --cc lib/fsync.c
Simple merge

diff --cc lib/get-permissions.c
Simple merge

diff --cc lib/getdtablesize.c
Simple merge

diff --cc lib/getgroups.c
Simple merge

diff --cc lib/getloadavg.c
Simple merge

diff --cc lib/getopt.c
Simple merge

diff --cc lib/gettext.h
Simple merge

diff --cc lib/gettime.c
Simple merge

diff --cc lib/gettimeofday.c
Simple merge

diff --cc lib/intprops.h
Simple merge

diff --cc lib/inttypes.in.h
Simple merge

diff --cc lib/limits.in.h
Simple merge

diff --cc lib/localtime-buffer.c
Simple merge

diff --cc lib/md5.c
Simple merge

diff --cc lib/md5.h
Simple merge

diff --cc lib/memrchr.c
Simple merge

diff --cc lib/mktime-internal.h
Simple merge

diff --cc lib/mktime.c
Simple merge

diff --cc lib/nstrftime.c
Simple merge

diff --cc lib/open.c
Simple merge

diff --cc lib/pipe2.c
Simple merge

diff --cc lib/pselect.c
Simple merge

diff --cc lib/putenv.c
Simple merge

diff --cc lib/set-permissions.c
Simple merge

diff --cc lib/sha1.c
Simple merge

diff --cc lib/sha1.h
Simple merge

diff --cc lib/sha256.c
Simple merge

diff --cc lib/sha256.h
Simple merge

diff --cc lib/sha512.c
Simple merge

diff --cc lib/sha512.h
Simple merge

diff --cc lib/stat-time.h
Simple merge

diff --cc lib/stdio-impl.h
Simple merge

diff --cc lib/stdio.in.h
Simple merge

diff --cc lib/stdlib.in.h
Simple merge

diff --cc lib/strtol.c
Simple merge

diff --cc lib/sys_stat.in.h
Simple merge

diff --cc lib/sys_types.in.h
Simple merge

diff --cc lib/time.in.h
Simple merge

diff --cc lib/time_rz.c
Simple merge

diff --cc lib/timespec-add.c
Simple merge

diff --cc lib/timespec-sub.c
Simple merge

diff --cc lib/timespec.h
Simple merge

diff --cc lib/unistd.in.h
Simple merge

diff --cc lib/utimens.c
Simple merge

diff --cc lib/verify.h
Simple merge

diff --cc lib/warn-on-use.h
Simple merge

diff --cc lisp/ChangeLog.2
Simple merge

diff --cc lisp/ChangeLog.4
Simple merge

diff --cc lisp/ChangeLog.5
Simple merge

diff --cc lisp/ChangeLog.7
Simple merge

diff --cc lisp/Makefile.in
Simple merge

diff --cc lisp/abbrev.el
Simple merge

diff --cc lisp/allout-widgets.el
Simple merge

diff --cc lisp/allout.el
Simple merge

diff --cc lisp/ansi-color.el
Simple merge

diff --cc lisp/apropos.el
Simple merge

diff --cc lisp/arc-mode.el
Simple merge

diff --cc lisp/auth-source-pass.el
Simple merge

diff --cc lisp/auth-source.el
Simple merge

diff --cc lisp/autoarg.el
Simple merge

diff --cc lisp/autoinsert.el
Simple merge

diff --cc lisp/autorevert.el
Simple merge

diff --cc lisp/avoid.el
Simple merge

diff --cc lisp/battery.el
Simple merge

diff --cc lisp/bindings.el
Simple merge

diff --cc lisp/bookmark.el
Simple merge

diff --cc lisp/bs.el
Simple merge

diff --cc lisp/calc/calc-alg.el
index 2f23399841ef8a561caf20d788a290b4b2c04ccf,8e3476d191e5266febb49217d9422420c86af23d..41ffc83d86f1eba249655821725cfe09ca1bd0c4
--- 1/lisp/calc/calc-alg.el
--- 2/lisp/calc/calc-alg.el
+++ b/lisp/calc/calc-alg.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calc-alg.el --- algebraic functions for Calc
 +;;; calc-alg.el --- algebraic functions for Calc  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  

diff --cc lisp/calc/calc-bin.el
Simple merge

diff --cc lisp/calc/calc-comb.el
Simple merge

diff --cc lisp/calc/calc-ext.el
index 761eb97a8169eabaf8175ada140a13dcb0a4ae01,f2e70906e94b73d6680109b217be38dcf54e6db0..1456fb28570677f2bd8148c0967512ecd1f3725e
--- 1/lisp/calc/calc-ext.el
--- 2/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calc-ext.el --- various extension functions for Calc
 +;;; calc-ext.el --- various extension functions for Calc  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  

diff --cc lisp/calc/calc-forms.el
Simple merge

diff --cc lisp/calc/calc-math.el
Simple merge

diff --cc lisp/calc/calc-poly.el
index 41083b7748038835ced6565d7dcb6b2793db9373,7e3e423868c390145b282a559f82f6991f6394f7..5fba85e059d0272039ec9f3e73c40fb00e1bcb4b
--- 1/lisp/calc/calc-poly.el
--- 2/lisp/calc/calc-poly.el
+++ b/lisp/calc/calc-poly.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calc-poly.el --- polynomial functions for Calc
 +;;; calc-poly.el --- polynomial functions for Calc  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  

diff --cc lisp/calc/calc-units.el
index 6e58eaf225f1b70fe98de01fdf7149c89b0f61be,8794d1f3c679e22d33c1a9b7507f29e89ba9e02e..86bebe6a9ed06b09f582c5230710c9101a8d5560
--- 1/lisp/calc/calc-units.el
--- 2/lisp/calc/calc-units.el
+++ b/lisp/calc/calc-units.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calc-units.el --- unit conversion functions for Calc
 +;;; calc-units.el --- unit conversion functions for Calc  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  

diff --cc lisp/calc/calc.el
index f155b8283b7c0e6e38a59ebea6aa479cc75cabcf,ef850a44fe6015bdfa9b8f4c7270f6753fbb0295..c1f23cc94e468ca6550073b43278d58fd52d4d3c
--- 1/lisp/calc/calc.el
--- 2/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calc.el --- the GNU Emacs calculator
 +;;; calc.el --- the GNU Emacs calculator  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  ;; Keywords: convenience, extensions

diff --cc lisp/calc/calccomp.el
index 75c7adc59ec4573de36ed85f667ec77fd293777a,d81cc04fe50e417d9ebe3f722028c6e414108e81..91eadfbb4e8579b296df7caed8a1da2303ae5a70
--- 1/lisp/calc/calccomp.el
--- 2/lisp/calc/calccomp.el
+++ b/lisp/calc/calccomp.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calccomp.el --- composition functions for Calc
 +;;; calccomp.el --- composition functions for Calc  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1993, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1990-1993, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: David Gillespie <daveg@synaptics.com>
  

diff --cc lisp/calculator.el
Simple merge

diff --cc lisp/calendar/appt.el
index 0259dd1e1e5523692f9f87acf951efadbcc61567,da041f024f83b52c6e6bb7032e07182db9d21d57..40cb9f7cbdb91840a2b4ba8d7be213eb8cbf45fa
--- 1/lisp/calendar/appt.el
--- 2/lisp/calendar/appt.el
+++ b/lisp/calendar/appt.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; appt.el --- appointment notification functions
 +;;; appt.el --- appointment notification functions  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1989-1990, 1994, 1998, 2001-2018 Free Software
+ ;; Copyright (C) 1989-1990, 1994, 1998, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Neil Mager <neilm@juliet.ll.mit.edu>

diff --cc lisp/calendar/cal-dst.el
index 8392e81b16fbc72b16d95725aa4a0fbf35039b97,e78f19f803f71821f64ac384fde0f9b9c167fd5e..567ba9c8a12bbf76c8412fb9d694cf7c2564d45f
--- 1/lisp/calendar/cal-dst.el
--- 2/lisp/calendar/cal-dst.el
+++ b/lisp/calendar/cal-dst.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; cal-dst.el --- calendar functions for daylight saving rules
 +;;; cal-dst.el --- calendar functions for daylight saving rules  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1993-1996, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1993-1996, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: Paul Eggert <eggert@twinsun.com>
  ;;         Edward M. Reingold <reingold@cs.uiuc.edu>

diff --cc lisp/calendar/cal-tex.el
Simple merge

diff --cc lisp/calendar/calendar.el
index 71fb76ce2139217d69a0742d632f5991b0e227b7,a15f15cf3079f7bbc41019a7139ca14643758a2c..de8f758fae88bb36eea74ba2736910b113fe71a8
--- 1/lisp/calendar/calendar.el
--- 2/lisp/calendar/calendar.el
+++ b/lisp/calendar/calendar.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; calendar.el --- calendar functions
 +;;; calendar.el --- calendar functions  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1988-1995, 1997, 2000-2018 Free Software Foundation,
+ ;; Copyright (C) 1988-1995, 1997, 2000-2019 Free Software Foundation,
  ;; Inc.
  
  ;; Author: Edward M. Reingold <reingold@cs.uiuc.edu>

diff --cc lisp/calendar/diary-lib.el
index 1cc59784c861711ed7b4751c9185f9bef54598ca,164363c2b70ecb74ceeeaca3dde3564ef93c6f21..1be2a05eee3e6cc616b3b16d4407f0c57e0c75e2
--- 1/lisp/calendar/diary-lib.el
--- 2/lisp/calendar/diary-lib.el
+++ b/lisp/calendar/diary-lib.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; diary-lib.el --- diary functions
 +;;; diary-lib.el --- diary functions  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1989-1990, 1992-1995, 2001-2018 Free Software
+ ;; Copyright (C) 1989-1990, 1992-1995, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Edward M. Reingold <reingold@cs.uiuc.edu>

diff --cc lisp/calendar/holidays.el
index 62b9d778e2ec75ce094e18b56247877fb7ad1cd2,40bc066c9ec8ab2d37448e2226826271ea31b5ad..2b080c30738237926ab85a2e696b501bdc0dd214
--- 1/lisp/calendar/holidays.el
--- 2/lisp/calendar/holidays.el
+++ b/lisp/calendar/holidays.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; holidays.el --- holiday functions for the calendar package
 +;;; holidays.el --- holiday functions for the calendar package  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1989-1990, 1992-1994, 1997, 2001-2018 Free Software
+ ;; Copyright (C) 1989-1990, 1992-1994, 1997, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Edward M. Reingold <reingold@cs.uiuc.edu>

diff --cc lisp/calendar/icalendar.el
Simple merge

diff --cc lisp/calendar/parse-time.el
Simple merge

diff --cc lisp/calendar/solar.el
index ddaf7451bd90155d0921da84e3dc24861bbe6fe7,aa5ab91f16e4d9ab8ab4fdce0748c337dea57234..23bc7611e5fa55b324f6ac7e8e83b6be5b4dd975
--- 1/lisp/calendar/solar.el
--- 2/lisp/calendar/solar.el
+++ b/lisp/calendar/solar.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; solar.el --- calendar functions for solar events
 +;;; solar.el --- calendar functions for solar events  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1992-1993, 1995, 1997, 2001-2018 Free Software
+ ;; Copyright (C) 1992-1993, 1995, 1997, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Edward M. Reingold <reingold@cs.uiuc.edu>

diff --cc lisp/calendar/time-date.el
Simple merge

diff --cc lisp/calendar/timeclock.el
index 646f5298fe4a10ed8cd25adb4217fa849157c569,769beddc3c487a0c72c8520debe6e79168019180..0562f4a998d6bd857520bd36d3c1129900e0d540
--- 1/lisp/calendar/timeclock.el
--- 2/lisp/calendar/timeclock.el
+++ b/lisp/calendar/timeclock.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; timeclock.el --- mode for keeping track of how much you work
 +;;; timeclock.el --- mode for keeping track of how much you work  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
  ;; Author: John Wiegley <johnw@gnu.org>
  ;; Created: 25 Mar 1999

diff --cc lisp/calendar/todo-mode.el
Simple merge

diff --cc lisp/cedet/cedet.el
Simple merge

diff --cc lisp/cedet/ede.el
Simple merge

diff --cc lisp/cedet/ede/detect.el
Simple merge

diff --cc lisp/cedet/ede/dired.el
Simple merge

diff --cc lisp/cedet/ede/files.el
Simple merge

diff --cc lisp/cedet/ede/linux.el
Simple merge

diff --cc lisp/cedet/ede/pconf.el
Simple merge

diff --cc lisp/cedet/ede/pmake.el
Simple merge

diff --cc lisp/cedet/ede/proj-archive.el
Simple merge

diff --cc lisp/cedet/ede/proj-aux.el
Simple merge

diff --cc lisp/cedet/ede/proj-comp.el
Simple merge

diff --cc lisp/cedet/ede/proj-elisp.el
Simple merge

diff --cc lisp/cedet/ede/proj-info.el
Simple merge

diff --cc lisp/cedet/ede/proj-misc.el
Simple merge

diff --cc lisp/cedet/ede/proj-obj.el
Simple merge

diff --cc lisp/cedet/ede/proj-prog.el
Simple merge

diff --cc lisp/cedet/ede/proj-shared.el
Simple merge

diff --cc lisp/cedet/ede/simple.el
Simple merge

diff --cc lisp/cedet/ede/source.el
Simple merge

diff --cc lisp/cedet/ede/speedbar.el
Simple merge

diff --cc lisp/cedet/mode-local.el
Simple merge

diff --cc lisp/cedet/pulse.el
Simple merge

diff --cc lisp/cedet/semantic.el
Simple merge

diff --cc lisp/cedet/semantic/analyze.el
Simple merge

diff --cc lisp/cedet/semantic/analyze/debug.el
Simple merge

diff --cc lisp/cedet/semantic/analyze/refs.el
Simple merge

diff --cc lisp/cedet/semantic/bovine.el
Simple merge

diff --cc lisp/cedet/semantic/bovine/c.el
Simple merge

diff --cc lisp/cedet/semantic/bovine/debug.el
Simple merge

diff --cc lisp/cedet/semantic/bovine/grammar.el
Simple merge

diff --cc lisp/cedet/semantic/complete.el
Simple merge

diff --cc lisp/cedet/semantic/db-file.el
Simple merge

diff --cc lisp/cedet/semantic/db-find.el
Simple merge

diff --cc lisp/cedet/semantic/db-javascript.el
Simple merge

diff --cc lisp/cedet/semantic/db-mode.el
Simple merge

diff --cc lisp/cedet/semantic/db-ref.el
Simple merge

diff --cc lisp/cedet/semantic/db.el
Simple merge

diff --cc lisp/cedet/semantic/debug.el
Simple merge

diff --cc lisp/cedet/semantic/decorate/mode.el
Simple merge

diff --cc lisp/cedet/semantic/dep.el
Simple merge

diff --cc lisp/cedet/semantic/ede-grammar.el
Simple merge

diff --cc lisp/cedet/semantic/grammar.el
Simple merge

diff --cc lisp/cedet/semantic/idle.el
Simple merge

diff --cc lisp/cedet/semantic/lex.el
Simple merge

diff --cc lisp/cedet/semantic/mru-bookmark.el
Simple merge

diff --cc lisp/cedet/semantic/sb.el
Simple merge

diff --cc lisp/cedet/semantic/scope.el
Simple merge

diff --cc lisp/cedet/semantic/symref/filter.el
Simple merge

diff --cc lisp/cedet/semantic/symref/grep.el
Simple merge

diff --cc lisp/cedet/semantic/symref/list.el
Simple merge

diff --cc lisp/cedet/semantic/texi.el
Simple merge

diff --cc lisp/cedet/semantic/util-modes.el
Simple merge

diff --cc lisp/cedet/semantic/util.el
Simple merge

diff --cc lisp/cedet/semantic/wisent/comp.el
Simple merge

diff --cc lisp/cedet/semantic/wisent/grammar.el
Simple merge

diff --cc lisp/cedet/semantic/wisent/python.el
Simple merge

diff --cc lisp/cedet/srecode/compile.el
Simple merge

diff --cc lisp/cedet/srecode/dictionary.el
Simple merge

diff --cc lisp/cedet/srecode/extract.el
Simple merge

diff --cc lisp/cedet/srecode/map.el
Simple merge

diff --cc lisp/cedet/srecode/mode.el
Simple merge

diff --cc lisp/cedet/srecode/srt-mode.el
Simple merge

diff --cc lisp/cedet/srecode/srt.el
Simple merge

diff --cc lisp/cedet/srecode/table.el
Simple merge

diff --cc lisp/char-fold.el
Simple merge

diff --cc lisp/chistory.el
Simple merge

diff --cc lisp/comint.el
Simple merge

diff --cc lisp/completion.el
Simple merge

diff --cc lisp/composite.el
Simple merge

diff --cc lisp/cus-edit.el
Simple merge

diff --cc lisp/cus-face.el
Simple merge

diff --cc lisp/cus-start.el
Simple merge

diff --cc lisp/cus-theme.el
index 995c55b2b202a46f2b36311932fdfeff21c44b21,c195f4afe2695b82cc3294309ca7e625210cb6e5..bc9d1d4f7d691a2e9c7e6a2c9e3ba3aad5e0e048
--- 1/lisp/cus-theme.el
--- 2/lisp/cus-theme.el
+++ b/lisp/cus-theme.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; cus-theme.el -- custom theme creation user interface
 +;;; cus-theme.el -- custom theme creation user interface  -*- lexical-binding: t -*-
  ;;
- ;; Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001-2019 Free Software Foundation, Inc.
  ;;
  ;; Author: Alex Schroeder <alex@gnu.org>
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/custom.el
index a08f7fda70532360a5f59f68e9f1a83162e6f197,f0125742d1fc56ec784817aaa0bc31975c89abc9..53b8045f058c8b02a1509932627c5a50993d11f2
--- 1/lisp/custom.el
--- 2/lisp/custom.el
+++ b/lisp/custom.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; custom.el --- tools for declaring and initializing options
 +;;; custom.el --- tools for declaring and initializing options  -*- lexical-binding: t -*-
  ;;
- ;; Copyright (C) 1996-1997, 1999, 2001-2018 Free Software Foundation,
+ ;; Copyright (C) 1996-1997, 1999, 2001-2019 Free Software Foundation,
  ;; Inc.
  ;;
  ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>

diff --cc lisp/dabbrev.el
Simple merge

diff --cc lisp/delim-col.el
index 076d4dc5c3d11ebf39bd08a9401e0eb8b4603cc5,d8116f3544be0abbe7c7034c68d9ab0d306854c3..a968b32052b9e48b0dbe09b6c4457d42e36e4246
--- 1/lisp/delim-col.el
--- 2/lisp/delim-col.el
+++ b/lisp/delim-col.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; delim-col.el --- prettify all columns in a region or rectangle
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Version: 2.1
  ;; Keywords: internal
  ;; X-URL: http://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre

diff --cc lisp/delsel.el
Simple merge

diff --cc lisp/descr-text.el
Simple merge

diff --cc lisp/desktop.el
Simple merge

diff --cc lisp/dired-aux.el
Simple merge

diff --cc lisp/dired-x.el
Simple merge

diff --cc lisp/dired.el
Simple merge

diff --cc lisp/dirtrack.el
Simple merge

diff --cc lisp/disp-table.el
Simple merge

diff --cc lisp/doc-view.el
Simple merge

diff --cc lisp/dom.el
Simple merge

diff --cc lisp/dos-fns.el
Simple merge

diff --cc lisp/dos-w32.el
Simple merge

diff --cc lisp/double.el
Simple merge

diff --cc lisp/ecomplete.el
index 3bfab4743cb8980e27767a9828b126c5d1df4447,c54c110867bc1f9baceb1425a3e0ea41c57b4350..9fc3f57833c64312de516f96e9fda16d4afb62ed
--- 1/lisp/ecomplete.el
--- 2/lisp/ecomplete.el
+++ b/lisp/ecomplete.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; ecomplete.el --- electric completion of addresses and the like
 +;;; ecomplete.el --- electric completion of addresses and the like  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2006-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2006-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  ;; Keywords: mail

diff --cc lisp/edmacro.el
Simple merge

diff --cc lisp/elec-pair.el
Simple merge

diff --cc lisp/electric.el
Simple merge

diff --cc lisp/emacs-lisp/advice.el
Simple merge

diff --cc lisp/emacs-lisp/autoload.el
Simple merge

diff --cc lisp/emacs-lisp/benchmark.el
Simple merge

diff --cc lisp/emacs-lisp/bindat.el
Simple merge

diff --cc lisp/emacs-lisp/byte-opt.el
Simple merge

diff --cc lisp/emacs-lisp/byte-run.el
Simple merge

diff --cc lisp/emacs-lisp/bytecomp.el
Simple merge

diff --cc lisp/emacs-lisp/cconv.el
Simple merge

diff --cc lisp/emacs-lisp/checkdoc.el
Simple merge

diff --cc lisp/emacs-lisp/cl-extra.el
Simple merge

diff --cc lisp/emacs-lisp/cl-generic.el
Simple merge

diff --cc lisp/emacs-lisp/cl-lib.el
Simple merge

diff --cc lisp/emacs-lisp/cl-macs.el
Simple merge

diff --cc lisp/emacs-lisp/cl-preloaded.el
Simple merge

diff --cc lisp/emacs-lisp/cl-print.el
Simple merge

diff --cc lisp/emacs-lisp/copyright.el
Simple merge

diff --cc lisp/emacs-lisp/crm.el
Simple merge

diff --cc lisp/emacs-lisp/debug.el
Simple merge

diff --cc lisp/emacs-lisp/derived.el
Simple merge

diff --cc lisp/emacs-lisp/easy-mmode.el
Simple merge

diff --cc lisp/emacs-lisp/easymenu.el
Simple merge

diff --cc lisp/emacs-lisp/edebug.el
Simple merge

diff --cc lisp/emacs-lisp/eieio-base.el
Simple merge

diff --cc lisp/emacs-lisp/eieio-compat.el
Simple merge

diff --cc lisp/emacs-lisp/eieio-core.el
Simple merge

diff --cc lisp/emacs-lisp/eieio.el
Simple merge

diff --cc lisp/emacs-lisp/eldoc.el
Simple merge

diff --cc lisp/emacs-lisp/elint.el
Simple merge

diff --cc lisp/emacs-lisp/elp.el
Simple merge

diff --cc lisp/emacs-lisp/ert.el
Simple merge

diff --cc lisp/emacs-lisp/ewoc.el
Simple merge

diff --cc lisp/emacs-lisp/find-func.el
Simple merge

diff --cc lisp/emacs-lisp/generator.el
Simple merge

diff --cc lisp/emacs-lisp/generic.el
Simple merge

diff --cc lisp/emacs-lisp/gv.el
Simple merge

diff --cc lisp/emacs-lisp/inline.el
Simple merge

diff --cc lisp/emacs-lisp/lisp-mnt.el
index 5c623a3ab8cd28922eaf6a6446269b086337ea0b,6cad17a4a1bd6d10267637009d19ef7c7a1b84a9..91c76158a31936dd14133b3c43fd6f163b001eba
--- 1/lisp/emacs-lisp/lisp-mnt.el
--- 2/lisp/emacs-lisp/lisp-mnt.el
+++ b/lisp/emacs-lisp/lisp-mnt.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; lisp-mnt.el --- utility functions for Emacs Lisp maintainers
 +;;; lisp-mnt.el --- utility functions for Emacs Lisp maintainers  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1992, 1994, 1997, 2000-2018 Free Software Foundation,
+ ;; Copyright (C) 1992, 1994, 1997, 2000-2019 Free Software Foundation,
  ;; Inc.
  
  ;; Author: Eric S. Raymond <esr@snark.thyrsus.com>

diff --cc lisp/emacs-lisp/lisp-mode.el
Simple merge

diff --cc lisp/emacs-lisp/lisp.el
Simple merge

diff --cc lisp/emacs-lisp/macroexp.el
Simple merge

diff --cc lisp/emacs-lisp/map-ynp.el
Simple merge

diff --cc lisp/emacs-lisp/map.el
Simple merge

diff --cc lisp/emacs-lisp/nadvice.el
Simple merge

diff --cc lisp/emacs-lisp/package-x.el
Simple merge

diff --cc lisp/emacs-lisp/package.el
Simple merge

diff --cc lisp/emacs-lisp/pcase.el
Simple merge

diff --cc lisp/emacs-lisp/radix-tree.el
Simple merge

diff --cc lisp/emacs-lisp/ring.el
Simple merge

diff --cc lisp/emacs-lisp/rx.el
Simple merge

diff --cc lisp/emacs-lisp/seq.el
Simple merge

diff --cc lisp/emacs-lisp/shadow.el
Simple merge

diff --cc lisp/emacs-lisp/smie.el
Simple merge

diff --cc lisp/emacs-lisp/subr-x.el
Simple merge

diff --cc lisp/emacs-lisp/syntax.el
Simple merge

diff --cc lisp/emacs-lisp/tcover-ses.el
Simple merge

diff --cc lisp/emacs-lisp/testcover.el
Simple merge

diff --cc lisp/emacs-lisp/thunk.el
Simple merge

diff --cc lisp/emacs-lisp/timer.el
Simple merge

diff --cc lisp/emacs-lisp/unsafep.el
Simple merge

diff --cc lisp/emacs-lisp/warnings.el
Simple merge

diff --cc lisp/emacs-lock.el
Simple merge

diff --cc lisp/emulation/cua-base.el
Simple merge

diff --cc lisp/emulation/viper-cmd.el
Simple merge

diff --cc lisp/emulation/viper-ex.el
Simple merge

diff --cc lisp/emulation/viper-keym.el
index cc0b7ebc3791fd5e5b3630a252062853b2a0ba67,c0b7a5b5c9c32f50d3343de4f9c6c04f113451ed..8bb75d65afa0b751d65bb0900fafde14539d7c31
--- 1/lisp/emulation/viper-keym.el
--- 2/lisp/emulation/viper-keym.el
+++ b/lisp/emulation/viper-keym.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; viper-keym.el --- Viper keymaps
 +;;; viper-keym.el --- Viper keymaps  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1994-1997, 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1994-1997, 2000-2019 Free Software Foundation, Inc.
  
  ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
  ;; Package: viper

diff --cc lisp/emulation/viper-macs.el
index cfb46cc19a89a09598840cde2256232f1901655f,90d33d5fa7bc6b988322e449a4f6671b0b65eb55..37ab81d78efdf82d18c103a54fe13269744f3d1b
--- 1/lisp/emulation/viper-macs.el
--- 2/lisp/emulation/viper-macs.el
+++ b/lisp/emulation/viper-macs.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; viper-macs.el --- functions implementing keyboard macros for Viper
 +;;; viper-macs.el --- functions implementing keyboard macros for Viper  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1994-1997, 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1994-1997, 2000-2019 Free Software Foundation, Inc.
  
  ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
  ;; Package: viper

diff --cc lisp/emulation/viper-util.el
index aa456551a68f1ab2bf6a07436880759e402920d3,04edc90c88a014213162ea4fce7fd07957eb4d41..a7e7af3bf850d4e4400c26b041c2d30361b6b928
--- 1/lisp/emulation/viper-util.el
--- 2/lisp/emulation/viper-util.el
+++ b/lisp/emulation/viper-util.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; viper-util.el --- Utilities used by viper.el
 +;;; viper-util.el --- Utilities used by viper.el  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1994-1997, 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1994-1997, 1999-2019 Free Software Foundation, Inc.
  
  ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
  ;; Package: viper

diff --cc lisp/emulation/viper.el
Simple merge

diff --cc lisp/env.el
Simple merge

diff --cc lisp/epa-file.el
Simple merge

diff --cc lisp/epa-hook.el
Simple merge

diff --cc lisp/epa-mail.el
Simple merge

diff --cc lisp/epa.el
Simple merge

diff --cc lisp/epg-config.el
Simple merge

diff --cc lisp/epg.el
Simple merge

diff --cc lisp/erc/erc-autoaway.el
Simple merge

diff --cc lisp/erc/erc-backend.el
Simple merge

diff --cc lisp/erc/erc-button.el
Simple merge

diff --cc lisp/erc/erc-capab.el
Simple merge

diff --cc lisp/erc/erc-compat.el
Simple merge

diff --cc lisp/erc/erc-dcc.el
Simple merge

diff --cc lisp/erc/erc-desktop-notifications.el
Simple merge

diff --cc lisp/erc/erc-ezbounce.el
Simple merge

diff --cc lisp/erc/erc-fill.el
Simple merge

diff --cc lisp/erc/erc-identd.el
Simple merge

diff --cc lisp/erc/erc-imenu.el
Simple merge

diff --cc lisp/erc/erc-join.el
Simple merge

diff --cc lisp/erc/erc-list.el
Simple merge

diff --cc lisp/erc/erc-log.el
Simple merge

diff --cc lisp/erc/erc-match.el
Simple merge

diff --cc lisp/erc/erc-menu.el
Simple merge

diff --cc lisp/erc/erc-netsplit.el
Simple merge

diff --cc lisp/erc/erc-notify.el
Simple merge

diff --cc lisp/erc/erc-page.el
Simple merge

diff --cc lisp/erc/erc-pcomplete.el
Simple merge

diff --cc lisp/erc/erc-replace.el
Simple merge

diff --cc lisp/erc/erc-ring.el
Simple merge

diff --cc lisp/erc/erc-services.el
index ac49a3e12ef8ea27ab2011fd02ecc490afb62da6,b6bceff205c8267d30818a48bb563705a4421dbf..886ba60eb47911d5681d77cbd52560e21b773ac7
--- 1/lisp/erc/erc-services.el
--- 2/lisp/erc/erc-services.el
+++ b/lisp/erc/erc-services.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; erc-services.el --- Identify to NickServ
 +;;; erc-services.el --- Identify to NickServ  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2002-2004, 2006-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2002-2004, 2006-2019 Free Software Foundation, Inc.
  
  ;; Maintainer: emacs-devel@gnu.org
  

diff --cc lisp/erc/erc-sound.el
Simple merge

diff --cc lisp/erc/erc-speedbar.el
Simple merge

diff --cc lisp/erc/erc-spelling.el
Simple merge

diff --cc lisp/erc/erc-stamp.el
Simple merge

diff --cc lisp/erc/erc-track.el
Simple merge

diff --cc lisp/erc/erc-truncate.el
Simple merge

diff --cc lisp/erc/erc-xdcc.el
Simple merge

diff --cc lisp/erc/erc.el
Simple merge

diff --cc lisp/eshell/em-basic.el
Simple merge

diff --cc lisp/eshell/em-cmpl.el
Simple merge

diff --cc lisp/eshell/em-dirs.el
Simple merge

diff --cc lisp/eshell/em-hist.el
Simple merge

diff --cc lisp/eshell/em-ls.el
Simple merge

diff --cc lisp/eshell/em-pred.el
Simple merge

diff --cc lisp/eshell/em-prompt.el
Simple merge

diff --cc lisp/eshell/em-script.el
Simple merge

diff --cc lisp/eshell/em-term.el
Simple merge

diff --cc lisp/eshell/em-tramp.el
Simple merge

diff --cc lisp/eshell/em-unix.el
Simple merge

diff --cc lisp/eshell/em-xtra.el
Simple merge

diff --cc lisp/eshell/esh-cmd.el
Simple merge

diff --cc lisp/eshell/esh-ext.el
Simple merge

diff --cc lisp/eshell/esh-mode.el
Simple merge

diff --cc lisp/eshell/esh-opt.el
Simple merge

diff --cc lisp/eshell/esh-proc.el
Simple merge

diff --cc lisp/eshell/esh-util.el
Simple merge

diff --cc lisp/eshell/esh-var.el
Simple merge

diff --cc lisp/face-remap.el
Simple merge

diff --cc lisp/facemenu.el
Simple merge

diff --cc lisp/faces.el
Simple merge

diff --cc lisp/ffap.el
Simple merge

diff --cc lisp/filecache.el
index 9dd631001da6933c33b07574822382c9a04d7d2a,eb4a64b768f474e955d0429be8730b47a4fd69ea..fb099c1802a4e76fd7f9168193bc942a3946f642
--- 1/lisp/filecache.el
--- 2/lisp/filecache.el
+++ b/lisp/filecache.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; filecache.el --- find files using a pre-loaded cache
 +;;; filecache.el --- find files using a pre-loaded cache  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1996, 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1996, 2000-2019 Free Software Foundation, Inc.
  
  ;; Author:  Peter Breton <pbreton@cs.umb.edu>
  ;; Created: Sun Nov 10 1996

diff --cc lisp/filenotify.el
Simple merge

diff --cc lisp/files-x.el
Simple merge

diff --cc lisp/files.el
Simple merge

diff --cc lisp/filesets.el
Simple merge

diff --cc lisp/find-dired.el
Simple merge

diff --cc lisp/find-lisp.el
Simple merge

diff --cc lisp/foldout.el
Simple merge

diff --cc lisp/follow.el
Simple merge

diff --cc lisp/font-core.el
Simple merge

diff --cc lisp/font-lock.el
index ee4b78b590ef9380031dbd5d9c4e41d200679355,d3828cf6b47934e61339e01005e1e38bb6d0687a..1475911195a16645ee2c6d3a5c15c6c7c2428a7c
--- 1/lisp/font-lock.el
--- 2/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; font-lock.el --- Electric font lock mode
 +;;; font-lock.el --- Electric font lock mode  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1992-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1992-2019 Free Software Foundation, Inc.
  
  ;; Author: Jamie Zawinski
  ;;    Richard Stallman

diff --cc lisp/format-spec.el
Simple merge

diff --cc lisp/format.el
Simple merge

diff --cc lisp/frame.el
Simple merge

diff --cc lisp/frameset.el
Simple merge

diff --cc lisp/fringe.el
index 583a0e2c20b325bc70ef1e5aa280e3b2b887ec05,31d80a8a77dbf4f84317ea51ef84cc4aee2aaa97..92387a21571a19aa1d9998e204ba1fe2bbee0056
--- 1/lisp/fringe.el
--- 2/lisp/fringe.el
+++ b/lisp/fringe.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; fringe.el --- fringe setup and control
 +;;; fringe.el --- fringe setup and control  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2002-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2002-2019 Free Software Foundation, Inc.
  
  ;; Author: Simon Josefsson <simon@josefsson.org>
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/generic-x.el
Simple merge

diff --cc lisp/gnus/canlock.el
Simple merge

diff --cc lisp/gnus/deuglify.el
Simple merge

diff --cc lisp/gnus/gnus-agent.el
Simple merge

diff --cc lisp/gnus/gnus-art.el
Simple merge

diff --cc lisp/gnus/gnus-async.el
Simple merge

diff --cc lisp/gnus/gnus-bcklg.el
Simple merge

diff --cc lisp/gnus/gnus-cache.el
Simple merge

diff --cc lisp/gnus/gnus-cite.el
Simple merge

diff --cc lisp/gnus/gnus-cloud.el
Simple merge

diff --cc lisp/gnus/gnus-cus.el
Simple merge

diff --cc lisp/gnus/gnus-demon.el
Simple merge

diff --cc lisp/gnus/gnus-draft.el
Simple merge

diff --cc lisp/gnus/gnus-dup.el
Simple merge

diff --cc lisp/gnus/gnus-fun.el
Simple merge

diff --cc lisp/gnus/gnus-group.el
Simple merge

diff --cc lisp/gnus/gnus-html.el
Simple merge

diff --cc lisp/gnus/gnus-icalendar.el
Simple merge

diff --cc lisp/gnus/gnus-int.el
Simple merge

diff --cc lisp/gnus/gnus-kill.el
Simple merge

diff --cc lisp/gnus/gnus-logic.el
Simple merge

diff --cc lisp/gnus/gnus-ml.el
Simple merge

diff --cc lisp/gnus/gnus-mlspl.el
Simple merge

diff --cc lisp/gnus/gnus-msg.el
Simple merge

diff --cc lisp/gnus/gnus-picon.el
Simple merge

diff --cc lisp/gnus/gnus-range.el
Simple merge

diff --cc lisp/gnus/gnus-registry.el
Simple merge

diff --cc lisp/gnus/gnus-salt.el
Simple merge

diff --cc lisp/gnus/gnus-score.el
Simple merge

diff --cc lisp/gnus/gnus-spec.el
Simple merge

diff --cc lisp/gnus/gnus-srvr.el
Simple merge

diff --cc lisp/gnus/gnus-start.el
Simple merge

diff --cc lisp/gnus/gnus-sum.el
Simple merge

diff --cc lisp/gnus/gnus-topic.el
Simple merge

diff --cc lisp/gnus/gnus-undo.el
Simple merge

diff --cc lisp/gnus/gnus-util.el
Simple merge

diff --cc lisp/gnus/gnus-uu.el
Simple merge

diff --cc lisp/gnus/gnus-vm.el
Simple merge

diff --cc lisp/gnus/gnus-win.el
Simple merge

diff --cc lisp/gnus/gnus.el
index 1ac02b4531c2676ead0bca79c4c07c79ec5c1b44,c3a57800e393349f3c52c154f43ac97e7d7da312..e5574d4f4f0281c857629d17ca3c616ed6843bc7
--- 1/lisp/gnus/gnus.el
--- 2/lisp/gnus/gnus.el
+++ b/lisp/gnus/gnus.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; gnus.el --- a newsreader for GNU Emacs
 +;;; gnus.el --- a newsreader for GNU Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1987-1990, 1993-1998, 2000-2018 Free Software
+ ;; Copyright (C) 1987-1990, 1993-1998, 2000-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>

diff --cc lisp/gnus/mail-source.el
Simple merge

diff --cc lisp/gnus/message.el
Simple merge

diff --cc lisp/gnus/mm-bodies.el
Simple merge

diff --cc lisp/gnus/mm-decode.el
index 3e6883b2a4b54adeb09b7da7f021ed8af39bad0e,5dad2acbdd03d7f343c84e0ec74e475311c2697f..80a2e50c4985ee40f37d2e9a015134e84a8e2dab
--- 1/lisp/gnus/mm-decode.el
--- 2/lisp/gnus/mm-decode.el
+++ b/lisp/gnus/mm-decode.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; mm-decode.el --- Functions for decoding MIME things
 +;;; mm-decode.el --- Functions for decoding MIME things  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  ;;    MORIOKA Tomohiko <morioka@jaist.ac.jp>

diff --cc lisp/gnus/mm-encode.el
Simple merge

diff --cc lisp/gnus/mm-extern.el
index fbae669ce940e8964b6264594245e7436e30ad91,32ba831a0da2c18251a90930c30cc9a8bf393b35..c3054432d51f20b4e698b11ec87db68f933bdb27
--- 1/lisp/gnus/mm-extern.el
--- 2/lisp/gnus/mm-extern.el
+++ b/lisp/gnus/mm-extern.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; mm-extern.el --- showing message/external-body
 +;;; mm-extern.el --- showing message/external-body  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2000-2019 Free Software Foundation, Inc.
  
  ;; Author: Shenghuo Zhu <zsh@cs.rochester.edu>
  ;; Keywords: message external-body

diff --cc lisp/gnus/mm-partial.el
Simple merge

diff --cc lisp/gnus/mm-url.el
Simple merge

diff --cc lisp/gnus/mm-util.el
index ba54b4e707432e8b0516044aee0fb0cca5def94b,bbaab536f1afc28cd87945c8b0814e951d403a84..00a8a532d279bb9c00b81505a85d87258ddd1806
--- 1/lisp/gnus/mm-util.el
--- 2/lisp/gnus/mm-util.el
+++ b/lisp/gnus/mm-util.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; mm-util.el --- Utility functions for Mule and low level things
 +;;; mm-util.el --- Utility functions for Mule and low level things  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  ;;    MORIOKA Tomohiko <morioka@jaist.ac.jp>

diff --cc lisp/gnus/mm-uu.el
Simple merge

diff --cc lisp/gnus/mm-view.el
Simple merge

diff --cc lisp/gnus/mml-sec.el
Simple merge

diff --cc lisp/gnus/mml-smime.el
Simple merge

diff --cc lisp/gnus/mml.el
Simple merge

diff --cc lisp/gnus/mml1991.el
Simple merge

diff --cc lisp/gnus/mml2015.el
Simple merge

diff --cc lisp/gnus/nnagent.el
Simple merge

diff --cc lisp/gnus/nnbabyl.el
Simple merge

diff --cc lisp/gnus/nndiary.el
Simple merge

diff --cc lisp/gnus/nndir.el
Simple merge

diff --cc lisp/gnus/nndoc.el
Simple merge

diff --cc lisp/gnus/nndraft.el
Simple merge

diff --cc lisp/gnus/nneething.el
Simple merge

diff --cc lisp/gnus/nnfolder.el
Simple merge

diff --cc lisp/gnus/nngateway.el
Simple merge

diff --cc lisp/gnus/nnheader.el
Simple merge

diff --cc lisp/gnus/nnimap.el
Simple merge

diff --cc lisp/gnus/nnir.el
Simple merge

diff --cc lisp/gnus/nnmail.el
Simple merge

diff --cc lisp/gnus/nnmairix.el
Simple merge

diff --cc lisp/gnus/nnmbox.el
Simple merge

diff --cc lisp/gnus/nnmh.el
Simple merge

diff --cc lisp/gnus/nnml.el
Simple merge

diff --cc lisp/gnus/nnoo.el
Simple merge

diff --cc lisp/gnus/nnrss.el
Simple merge

diff --cc lisp/gnus/nnspool.el
Simple merge

diff --cc lisp/gnus/nntp.el
Simple merge

diff --cc lisp/gnus/nnvirtual.el
Simple merge

diff --cc lisp/gnus/nnweb.el
Simple merge

diff --cc lisp/gnus/score-mode.el
Simple merge

diff --cc lisp/gnus/smiley.el
Simple merge

diff --cc lisp/gnus/smime.el
Simple merge

diff --cc lisp/gnus/spam-stat.el
Simple merge

diff --cc lisp/gnus/spam.el
Simple merge

diff --cc lisp/help-fns.el
Simple merge

diff --cc lisp/help-mode.el
Simple merge

diff --cc lisp/help.el
index ad782f74cacbd6321da9cba369c617f70191a64b,c23d4d8fe54ab89b5cd9f097b1d60c4adb2b795c..5fa1876b38e2a5b23a2dca15927850754d0dae49
--- 1/lisp/help.el
--- 2/lisp/help.el
+++ b/lisp/help.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; help.el --- help commands for Emacs
 +;;; help.el --- help commands for Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1985-1986, 1993-1994, 1998-2018 Free Software
+ ;; Copyright (C) 1985-1986, 1993-1994, 1998-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/hexl.el
Simple merge

diff --cc lisp/hfy-cmap.el
index ee6e18edb0aa4eaa6752ffeee1370ab7194aa616,310805652f25d2ce6f24be072571ca05d3cfcbc4..a34efa60b4e9d0a89ff104168f70f7af0299e538
--- 1/lisp/hfy-cmap.el
--- 2/lisp/hfy-cmap.el
+++ b/lisp/hfy-cmap.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; hfy-cmap.el --- Fallback colour name -> rgb mapping for `htmlfontify'
 +;;; hfy-cmap.el --- Fallback color name -> rgb mapping for `htmlfontify'
  
- ;; Copyright (C) 2002-2003, 2009-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2002-2003, 2009-2019 Free Software Foundation, Inc.
  
  ;; Emacs Lisp Archive Entry
  ;; Package: htmlfontify

diff --cc lisp/hi-lock.el
Simple merge

diff --cc lisp/hilit-chg.el
Simple merge

diff --cc lisp/hl-line.el
Simple merge

diff --cc lisp/htmlfontify.el
Simple merge

diff --cc lisp/ibuf-ext.el
Simple merge

diff --cc lisp/ibuf-macs.el
Simple merge

diff --cc lisp/ibuffer.el
Simple merge

diff --cc lisp/icomplete.el
Simple merge

diff --cc lisp/ido.el
Simple merge

diff --cc lisp/ielm.el
Simple merge

diff --cc lisp/image-dired.el
Simple merge

diff --cc lisp/image-file.el
Simple merge

diff --cc lisp/image-mode.el
Simple merge

diff --cc lisp/image.el
Simple merge

diff --cc lisp/image/gravatar.el
Simple merge

diff --cc lisp/imenu.el
Simple merge

diff --cc lisp/indent.el
Simple merge

diff --cc lisp/info-look.el
Simple merge

diff --cc lisp/info.el
Simple merge

diff --cc lisp/international/ccl.el
Simple merge

diff --cc lisp/international/fontset.el
Simple merge

diff --cc lisp/international/iso-ascii.el
Simple merge

diff --cc lisp/international/latin1-disp.el
Simple merge

diff --cc lisp/international/mule-cmds.el
Simple merge

diff --cc lisp/international/mule-conf.el
Simple merge

diff --cc lisp/international/mule-diag.el
Simple merge

diff --cc lisp/international/mule-util.el
Simple merge

diff --cc lisp/international/mule.el
Simple merge

diff --cc lisp/international/quail.el
Simple merge

diff --cc lisp/isearch.el
Simple merge

diff --cc lisp/jit-lock.el
Simple merge

diff --cc lisp/jka-cmpr-hook.el
Simple merge

diff --cc lisp/json.el
Simple merge

diff --cc lisp/kmacro.el
Simple merge

diff --cc lisp/language/cyrillic.el
Simple merge

diff --cc lisp/language/english.el
Simple merge

diff --cc lisp/language/european.el
Simple merge

diff --cc lisp/language/georgian.el
Simple merge

diff --cc lisp/language/thai-util.el
Simple merge

diff --cc lisp/language/tibetan.el
Simple merge

diff --cc lisp/language/utf-8-lang.el
Simple merge

diff --cc lisp/language/vietnamese.el
Simple merge

diff --cc lisp/leim/quail/latin-post.el
Simple merge

diff --cc lisp/leim/quail/latin-pre.el
Simple merge

diff --cc lisp/linum.el
Simple merge

diff --cc lisp/loadhist.el
Simple merge

diff --cc lisp/loadup.el
Simple merge

diff --cc lisp/locate.el
Simple merge

diff --cc lisp/lpr.el
Simple merge

diff --cc lisp/ls-lisp.el
Simple merge

diff --cc lisp/macros.el
index 4078b983ec67b0233e032be4c41d4541d302751f,27a14694ee65e93b37e542f01e2caf94a969186b..ba6a840d60c05d248d99fdb7ed69c51c303b1269
--- 1/lisp/macros.el
--- 2/lisp/macros.el
+++ b/lisp/macros.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; macros.el --- non-primitive commands for keyboard macros
 +;;; macros.el --- non-primitive commands for keyboard macros -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1985-1987, 1992, 1994-1995, 2001-2018 Free Software
+ ;; Copyright (C) 1985-1987, 1992, 1994-1995, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/mail/binhex.el
index fa2ea3d847198a893ea1d9192397f5ea00d2abf8,eb00b87f4c1587a5aed04308a0d631aa11db2d09..19fcbaaf475c9c6ba3e73cb08e7b007cbad4a864
--- 1/lisp/mail/binhex.el
--- 2/lisp/mail/binhex.el
+++ b/lisp/mail/binhex.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; binhex.el --- decode BinHex-encoded text
 +;;; binhex.el --- decode BinHex-encoded text  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Shenghuo Zhu <zsh@cs.rochester.edu>
  ;; Keywords: binhex news

diff --cc lisp/mail/blessmail.el
Simple merge

diff --cc lisp/mail/emacsbug.el
Simple merge

diff --cc lisp/mail/flow-fill.el
index db2a30ad15eaaa3962d319931f934ca6f709b354,8451315a12ea4ad9ca093268084b15e5ec6c3107..06279d4041c840cebaaf83a62377de85b3cf5328
--- 1/lisp/mail/flow-fill.el
--- 2/lisp/mail/flow-fill.el
+++ b/lisp/mail/flow-fill.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; flow-fill.el --- interpret RFC2646 "flowed" text
 +;;; flow-fill.el --- interpret RFC2646 "flowed" text  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2000-2019 Free Software Foundation, Inc.
  
  ;; Author: Simon Josefsson <jas@pdc.kth.se>
  ;; Keywords: mail

diff --cc lisp/mail/footnote.el
index f5d280ae1ead056dd2d6f196c7226edfb3598a99,be3a878f8328d10d4e30c55235f2c96ada69a348..a7802929dca8066628db8ecffdb445ea7fc243db
--- 1/lisp/mail/footnote.el
--- 2/lisp/mail/footnote.el
+++ b/lisp/mail/footnote.el
@@@ -1,9 -1,8 +1,9 @@@
 -;;; footnote.el --- footnote support for message mode
 +;;; footnote.el --- footnote support for message mode  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1997, 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1997, 2000-2019 Free Software Foundation, Inc.
  
 -;; Author: Steven L Baur <steve@xemacs.org>
 +;; Author: Steven L Baur <steve@xemacs.org> (1997-2011)
 +;;         Boruch Baum <boruch_baum@gmx.com> (2017-)
  ;; Keywords: mail, news
  ;; Version: 0.19
  

diff --cc lisp/mail/hashcash.el
index 37b2d94e5f56cb78cd8f12eba583b5bb17236751,9fdc7ea756c9776f2d3a6252792763bb98d5bd9e..59200eaab88d019a6b6695491adba45a12a27af8
--- 1/lisp/mail/hashcash.el
--- 2/lisp/mail/hashcash.el
+++ b/lisp/mail/hashcash.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; hashcash.el --- Add hashcash payments to email
 +;;; hashcash.el --- Add hashcash payments to email  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2003-2005, 2007-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2003-2005, 2007-2019 Free Software Foundation, Inc.
  
  ;; Written by: Paul Foley <mycroft@actrix.gen.nz> (1997-2002)
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/mail/ietf-drums.el
index 0af3221fc33373a369c66beebd2adc7ee89b07b4,6501a99f7bc7e5055d7ad122f841e862fb8ca85b..66006573c14795a8218c11df28938824ed792a66
--- 1/lisp/mail/ietf-drums.el
--- 2/lisp/mail/ietf-drums.el
+++ b/lisp/mail/ietf-drums.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; ietf-drums.el --- Functions for parsing RFC822bis headers
 +;;; ietf-drums.el --- Functions for parsing RFC822bis headers  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  ;; This file is part of GNU Emacs.

diff --cc lisp/mail/mail-extr.el
Simple merge

diff --cc lisp/mail/mail-utils.el
Simple merge

diff --cc lisp/mail/mailabbrev.el
Simple merge

diff --cc lisp/mail/mailalias.el
Simple merge

diff --cc lisp/mail/mspools.el
Simple merge

diff --cc lisp/mail/rfc2047.el
Simple merge

diff --cc lisp/mail/rfc2231.el
index 103af55248a5f22934debc00e78fac2f456b5057,31112a7505a641133aa14a18d4c09118958cba59..0a0983c25f82c0c03dc8140c4478890e9030c3a5
--- 1/lisp/mail/rfc2231.el
--- 2/lisp/mail/rfc2231.el
+++ b/lisp/mail/rfc2231.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; rfc2231.el --- Functions for decoding rfc2231 headers
 +;;; rfc2231.el --- Functions for decoding rfc2231 headers  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  ;; This file is part of GNU Emacs.

diff --cc lisp/mail/rmail-spam-filter.el
Simple merge

diff --cc lisp/mail/rmail.el
Simple merge

diff --cc lisp/mail/rmailout.el
Simple merge

diff --cc lisp/mail/rmailsum.el
Simple merge

diff --cc lisp/mail/sendmail.el
index 6fc91a3acd90864f78d7f3b98986fc555bb7df37,58a2cd1601165df77571592cbb65a8eb8e872f92..9315d6ac6275ef281b986f77c467663f6ba4ce5b
--- 1/lisp/mail/sendmail.el
--- 2/lisp/mail/sendmail.el
+++ b/lisp/mail/sendmail.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; sendmail.el --- mail sending commands for Emacs
 +;;; sendmail.el --- mail sending commands for Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1985-1986, 1992-1996, 1998, 2000-2018 Free Software
+ ;; Copyright (C) 1985-1986, 1992-1996, 1998, 2000-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/mail/smtpmail.el
index 8a1e86b775003bbd81d137d7fed9a5dd595265ab,5b28c271038cb9f0d75c5a5b07414180e4c37643..49645aba7a12b45ca9540d5c4087f87a22214ae8
--- 1/lisp/mail/smtpmail.el
--- 2/lisp/mail/smtpmail.el
+++ b/lisp/mail/smtpmail.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; smtpmail.el --- simple SMTP protocol (RFC 821) for sending mail
 +;;; smtpmail.el --- simple SMTP protocol (RFC 821) for sending mail  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1995-1996, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1995-1996, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: Tomoji Kagatani <kagatani@rbc.ncl.omron.co.jp>
  ;; Maintainer: Simon Josefsson <simon@josefsson.org>

diff --cc lisp/mail/supercite.el
Simple merge

diff --cc lisp/mail/uce.el
Simple merge

diff --cc lisp/mail/uudecode.el
index b8f74e3a839bc75dbb003c8bba1dae48e2e07cac,a78202938e44f2552202baf37a724d15c121c7a7..32e668baab35913d26330ef1cc36c1c3b523d7e4
--- 1/lisp/mail/uudecode.el
--- 2/lisp/mail/uudecode.el
+++ b/lisp/mail/uudecode.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; uudecode.el -- elisp native uudecode
 +;;; uudecode.el -- elisp native uudecode  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Shenghuo Zhu <zsh@cs.rochester.edu>
  ;; Keywords: uudecode news

diff --cc lisp/mail/yenc.el
index 25b4ebb9bda88e987f214239e578ddfffb7c76de,f7a12d6c9e25698a163d6e6b907be084e6ca84a4..75b62c14117949085c4d2e23a5bf1b3d24f4278e
--- 1/lisp/mail/yenc.el
--- 2/lisp/mail/yenc.el
+++ b/lisp/mail/yenc.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; yenc.el --- elisp native yenc decoder
 +;;; yenc.el --- elisp native yenc decoder  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2002-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2002-2019 Free Software Foundation, Inc.
  
  ;; Author: Jesper Harder <harder@ifa.au.dk>
  ;; Keywords: yenc news

diff --cc lisp/man.el
Simple merge

diff --cc lisp/master.el
Simple merge

diff --cc lisp/mb-depth.el
Simple merge

diff --cc lisp/md4.el
Simple merge

diff --cc lisp/menu-bar.el
Simple merge

diff --cc lisp/mh-e/mh-acros.el
Simple merge

diff --cc lisp/mh-e/mh-alias.el
Simple merge

diff --cc lisp/mh-e/mh-comp.el
Simple merge

diff --cc lisp/mh-e/mh-compat.el
Simple merge

diff --cc lisp/mh-e/mh-e.el
Simple merge

diff --cc lisp/mh-e/mh-folder.el
Simple merge

diff --cc lisp/mh-e/mh-funcs.el
Simple merge

diff --cc lisp/mh-e/mh-identity.el
Simple merge

diff --cc lisp/mh-e/mh-junk.el
Simple merge

diff --cc lisp/mh-e/mh-letter.el
Simple merge

diff --cc lisp/mh-e/mh-mime.el
Simple merge

diff --cc lisp/mh-e/mh-show.el
Simple merge

diff --cc lisp/mh-e/mh-speed.el
Simple merge

diff --cc lisp/mh-e/mh-thread.el
Simple merge

diff --cc lisp/mh-e/mh-utils.el
Simple merge

diff --cc lisp/minibuf-eldef.el
Simple merge

diff --cc lisp/minibuffer.el
Simple merge

diff --cc lisp/mouse.el
Simple merge

diff --cc lisp/mpc.el
Simple merge

diff --cc lisp/msb.el
Simple merge

diff --cc lisp/mwheel.el
Simple merge

diff --cc lisp/net/ange-ftp.el
index 8828010ab41e167591ddadb2363f778518559833,f400c562939116b3b2040360834492b206166397..f2ee89504947eedc862be2a040e45b415189778b
--- 1/lisp/net/ange-ftp.el
--- 2/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; ange-ftp.el --- transparent FTP support for GNU Emacs
 +;;; ange-ftp.el --- transparent FTP support for GNU Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1989-1996, 1998, 2000-2018 Free Software Foundation,
+ ;; Copyright (C) 1989-1996, 1998, 2000-2019 Free Software Foundation,
  ;; Inc.
  
  ;; Author: Andy Norman (ange@hplb.hpl.hp.com)

diff --cc lisp/net/browse-url.el
Simple merge

diff --cc lisp/net/dbus.el
Simple merge

diff --cc lisp/net/dns.el
Simple merge

diff --cc lisp/net/eudc-bob.el
Simple merge

diff --cc lisp/net/eudc-hotlist.el
Simple merge

diff --cc lisp/net/eudc.el
index a28fa6aa17ad6c5bc1edbc0013a5c44d1aeb0d1c,bc550fbc1130447a85d20f2c52f1876180ee735b..3c9c01d0f96e1890cbc41fbe178a1223c89bb47e
--- 1/lisp/net/eudc.el
--- 2/lisp/net/eudc.el
+++ b/lisp/net/eudc.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; eudc.el --- Emacs Unified Directory Client
 +;;; eudc.el --- Emacs Unified Directory Client  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Oscar Figueiredo <oscar@cpe.fr>
  ;;         Pavel Janík <Pavel@Janik.cz>

diff --cc lisp/net/eudcb-bbdb.el
Simple merge

diff --cc lisp/net/eudcb-mab.el
Simple merge

diff --cc lisp/net/eww.el
Simple merge

diff --cc lisp/net/gnutls.el
Simple merge

diff --cc lisp/net/goto-addr.el
Simple merge

diff --cc lisp/net/hmac-def.el
Simple merge

diff --cc lisp/net/imap.el
index 042b0f9a2c9d9cfdb228d8feaa62b18a90eaf12e,f4ae7b94495958b47b78eb7650d6942add4470cb..504900eabe90b772603a8a47cb7bb54c9759975b
--- 1/lisp/net/imap.el
--- 2/lisp/net/imap.el
+++ b/lisp/net/imap.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; imap.el --- imap library
 +;;; imap.el --- imap library  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Simon Josefsson <simon@josefsson.org>
  ;; Keywords: mail

diff --cc lisp/net/ldap.el
Simple merge

diff --cc lisp/net/mailcap.el
Simple merge

diff --cc lisp/net/net-utils.el
Simple merge

diff --cc lisp/net/netrc.el
Simple merge

diff --cc lisp/net/network-stream.el
Simple merge

diff --cc lisp/net/newst-backend.el
index 40096ca4c1e266ea8220a35eca51e3fdfcf875c4,94101fb0b25b02ad624a1096bac91afb20ac2228..bb7b7bcc1b01462798d1e56373d4363853b52db6
--- 1/lisp/net/newst-backend.el
--- 2/lisp/net/newst-backend.el
+++ b/lisp/net/newst-backend.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; newst-backend.el --- Retrieval backend for newsticker.
 +;;; newst-backend.el --- Retrieval backend for newsticker  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2003-2019 Free Software Foundation, Inc.
  
  ;; Author:      Ulf Jasper <ulf.jasper@web.de>
  ;; Filename:    newst-backend.el

diff --cc lisp/net/newst-plainview.el
Simple merge

diff --cc lisp/net/newst-treeview.el
Simple merge

diff --cc lisp/net/nsm.el
Simple merge

diff --cc lisp/net/ntlm.el
index 142c37510ecf990e52543aca2138a46da0cb0345,d3899e45eae4f6342a6fa5fb154624c353d291a5..88c561910cb6b38a8c0ed5e87c82fd8d7ed4c116
--- 1/lisp/net/ntlm.el
--- 2/lisp/net/ntlm.el
+++ b/lisp/net/ntlm.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; ntlm.el --- NTLM (NT LanManager) authentication support
 +;;; ntlm.el --- NTLM (NT LanManager) authentication support  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2001, 2007-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001, 2007-2019 Free Software Foundation, Inc.
  
  ;; Author: Taro Kawagishi <tarok@transpulse.org>
  ;; Maintainer: Thomas Fitzsimmons <fitzsim@fitzsim.org>

diff --cc lisp/net/pop3.el
index 2a6807e1aca4de98934ba38e407f08bc689ba9e7,f73607081c5aa04b7fccaebbfe048c7b0f11b3eb..bcf56c9ab3fe16c92b0504b35ab25584b181d484
--- 1/lisp/net/pop3.el
--- 2/lisp/net/pop3.el
+++ b/lisp/net/pop3.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; pop3.el --- Post Office Protocol (RFC 1460) interface
 +;;; pop3.el --- Post Office Protocol (RFC 1460) interface  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1996-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1996-2019 Free Software Foundation, Inc.
  
  ;; Author: Richard L. Pieri <ratinox@peorth.gweep.net>
  ;; Maintainer: emacs-devel@gnu.org

diff --cc lisp/net/puny.el
Simple merge

diff --cc lisp/net/quickurl.el
Simple merge

diff --cc lisp/net/rcirc.el
Simple merge

diff --cc lisp/net/rfc2104.el
index 57bca2e8788284ac644eb0e1443a492ea6658e98,3b000399b99e160256cb151a6e459b3c24f01363..68c35aa3130c1cd30ec2a187ef300111983fc059
--- 1/lisp/net/rfc2104.el
--- 2/lisp/net/rfc2104.el
+++ b/lisp/net/rfc2104.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; rfc2104.el --- RFC2104 Hashed Message Authentication Codes
 +;;; rfc2104.el --- RFC2104 Hashed Message Authentication Codes  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
  ;; Author: Simon Josefsson <jas@pdc.kth.se>
  ;; Keywords: mail

diff --cc lisp/net/rlogin.el
index 015e04f4075ac228a7cc2134124bbb8652c9f1f7,f73638699d4d9d0ed1ee84df1c577ba280ffe3e1..bf6f5359aad41014dc6a524e2131da19329e4e8f
--- 1/lisp/net/rlogin.el
--- 2/lisp/net/rlogin.el
+++ b/lisp/net/rlogin.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; rlogin.el --- remote login interface
 +;;; rlogin.el --- remote login interface  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1992-1995, 1997-1998, 2001-2018 Free Software
+ ;; Copyright (C) 1992-1995, 1997-1998, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Noah Friedman

diff --cc lisp/net/sasl.el
Simple merge

diff --cc lisp/net/secrets.el
Simple merge

diff --cc lisp/net/shr-color.el
index 6303141c8980a341630f290f57359e9dc2b2ad89,fcc307b929cd04c6234caf617797b685f53dff30..2d6cf68d8ff5522a56643eded6bc9096fe2b47d2
--- 1/lisp/net/shr-color.el
--- 2/lisp/net/shr-color.el
+++ b/lisp/net/shr-color.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; shr-color.el --- Simple HTML Renderer color management
 +;;; shr-color.el --- Simple HTML Renderer color management  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2010-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2010-2019 Free Software Foundation, Inc.
  
  ;; Author: Julien Danjou <julien@danjou.info>
  ;; Keywords: html

diff --cc lisp/net/shr.el
Simple merge

diff --cc lisp/net/sieve-manage.el
index 8c70ae037aba2242ca3d466dc1543c6d917a97d3,18a3dcc4c09f809a2b25ee5260c2ca38ea05a514..72731b8fdae72ba634dfef3b48b0d9082da33056
--- 1/lisp/net/sieve-manage.el
--- 2/lisp/net/sieve-manage.el
+++ b/lisp/net/sieve-manage.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; sieve-manage.el --- Implementation of the managesieve protocol in elisp
 +;;; sieve-manage.el --- Implementation of the managesieve protocol in elisp  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: Simon Josefsson <simon@josefsson.org>
  ;;         Albert Krewinkel <tarleb@moltkeplatz.de>

diff --cc lisp/net/sieve-mode.el
Simple merge

diff --cc lisp/net/sieve.el
Simple merge

diff --cc lisp/net/soap-client.el
Simple merge

diff --cc lisp/net/socks.el
index 5ee6eea933f247e246c4ab1dd8a02bf031e82a5d,c2a8b699cd54ac5164916c22bf0022c5d70b2b46..6356707a1dbc4c03afd627b746df4e483484ffe4
--- 1/lisp/net/socks.el
--- 2/lisp/net/socks.el
+++ b/lisp/net/socks.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; socks.el --- A Socks v5 Client for Emacs
 +;;; socks.el --- A Socks v5 Client for Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1996-2000, 2002, 2007-2018 Free Software Foundation,
+ ;; Copyright (C) 1996-2000, 2002, 2007-2019 Free Software Foundation,
  ;; Inc.
  
  ;; Author: William M. Perry <wmperry@gnu.org>

diff --cc lisp/net/tramp-adb.el
Simple merge

diff --cc lisp/net/tramp-cache.el
Simple merge

diff --cc lisp/net/tramp-cmds.el
Simple merge

diff --cc lisp/net/tramp-compat.el
Simple merge

diff --cc lisp/net/tramp-ftp.el
Simple merge

diff --cc lisp/net/tramp-gvfs.el
Simple merge

diff --cc lisp/net/tramp-sh.el
Simple merge

diff --cc lisp/net/tramp-smb.el
Simple merge

diff --cc lisp/net/tramp.el
Simple merge

diff --cc lisp/net/trampver.el
Simple merge

diff --cc lisp/net/zeroconf.el
Simple merge

diff --cc lisp/newcomment.el
Simple merge

diff --cc lisp/notifications.el
Simple merge

diff --cc lisp/novice.el
Simple merge

diff --cc lisp/nxml/nxml-mode.el
Simple merge

diff --cc lisp/nxml/rng-loc.el
Simple merge

diff --cc lisp/nxml/rng-maint.el
Simple merge

diff --cc lisp/obsolete/assoc.el
Simple merge

diff --cc lisp/obsolete/complete.el
Simple merge

diff --cc lisp/obsolete/crisp.el
Simple merge

diff --cc lisp/obsolete/fast-lock.el
Simple merge

diff --cc lisp/obsolete/iswitchb.el
Simple merge

diff --cc lisp/obsolete/lazy-lock.el
Simple merge

diff --cc lisp/obsolete/levents.el
Simple merge

diff --cc lisp/obsolete/longlines.el
Simple merge

diff --cc lisp/obsolete/mouse-sel.el
Simple merge

diff --cc lisp/obsolete/old-whitespace.el
Simple merge

diff --cc lisp/obsolete/pgg-gpg.el
Simple merge

diff --cc lisp/obsolete/pgg-parse.el
Simple merge

diff --cc lisp/obsolete/pgg-pgp.el
Simple merge

diff --cc lisp/obsolete/pgg-pgp5.el
Simple merge

diff --cc lisp/obsolete/pgg.el
Simple merge

diff --cc lisp/obsolete/sregex.el
Simple merge

diff --cc lisp/obsolete/starttls.el
index 0dc2663870a96988b3c6fe9b7c861b39750c15ef,0000000000000000000000000000000000000000..b89e612e4a34c194e11b6b6c2bbc40ddc5094531
mode 100644,000000..100644
--- 1/lisp/obsolete/starttls.el
--- /dev/null
+++ b/lisp/obsolete/starttls.el
@@@ -1,305 -1,0 +1,305 @@@
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
 +;;; starttls.el --- STARTTLS functions
 +
++;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
 +
 +;; Author: Daiki Ueno <ueno@unixuser.org>
 +;; Author: Simon Josefsson <simon@josefsson.org>
 +;; Created: 1999/11/20
 +;; Keywords: TLS, SSL, OpenSSL, GnuTLS, mail, news
 +;; Obsolete-since: 27.1
 +
 +;; This file is part of GNU Emacs.
 +
 +;; GNU Emacs is free software: you can redistribute it and/or modify
 +;; it under the terms of the GNU General Public License as published by
 +;; the Free Software Foundation, either version 3 of the License, or
 +;; (at your option) any later version.
 +
 +;; GNU Emacs is distributed in the hope that it will be useful,
 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +;; GNU General Public License for more details.
 +
 +;; You should have received a copy of the GNU General Public License
 +;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
 +
 +;;; Commentary:
 +
 +;; This module defines some utility functions for STARTTLS profiles.
 +
 +;; [RFC 2595] "Using TLS with IMAP, POP3 and ACAP"
 +;;    by Chris Newman <chris.newman@innosoft.com> (1999/06)
 +
 +;; This file now contains a combination of the two previous
 +;; implementations both called "starttls.el".  The first one is Daiki
 +;; Ueno's starttls.el which uses his own "starttls" command line tool,
 +;; and the second one is Simon Josefsson's starttls.el which uses
 +;; "gnutls-cli" from GnuTLS.
 +;;
 +;; If "starttls" is available, it is preferred by the code over
 +;; "gnutls-cli", for backwards compatibility.  Use
 +;; `starttls-use-gnutls' to toggle between implementations if you have
 +;; both tools installed.  It is recommended to use GnuTLS, though, as
 +;; it performs more verification of the certificates.
 +
 +;; The GnuTLS support requires GnuTLS 0.9.90 (released 2003-10-08) or
 +;; later, from <https://www.gnu.org/software/gnutls/>, or "starttls"
 +;; from <ftp://ftp.opaopa.org/pub/elisp/>.
 +
 +;; Usage is similar to `open-network-stream'.  For example:
 +;;
 +;; (when (setq tmp (starttls-open-stream
 +;;                    "test" (current-buffer) "yxa.extundo.com" 25))
 +;;   (accept-process-output tmp 15)
 +;;   (process-send-string tmp "STARTTLS\n")
 +;;   (accept-process-output tmp 15)
 +;;   (message "STARTTLS output:\n%s" (starttls-negotiate tmp))
 +;;   (process-send-string tmp "EHLO foo\n"))
 +
 +;; An example run yields the following output:
 +;;
 +;; 220 yxa.extundo.com ESMTP Sendmail 8.12.11/8.12.11/Debian-3; Wed, 26 May 2004 19:12:29 +0200; (No UCE/UBE) logging access from: c494102a.s-bi.bostream.se(OK)-c494102a.s-bi.bostream.se [217.215.27.65]
 +;; 220 2.0.0 Ready to start TLS
 +;; 250-yxa.extundo.com Hello c494102a.s-bi.bostream.se [217.215.27.65], pleased to meet you
 +;; 250-ENHANCEDSTATUSCODES
 +;; 250-PIPELINING
 +;; 250-EXPN
 +;; 250-VERB
 +;; 250-8BITMIME
 +;; 250-SIZE
 +;; 250-DSN
 +;; 250-ETRN
 +;; 250-AUTH DIGEST-MD5 CRAM-MD5 PLAIN LOGIN
 +;; 250-DELIVERBY
 +;; 250 HELP
 +;; nil
 +;;
 +;; With the message buffer containing:
 +;;
 +;; STARTTLS output:
 +;; *** Starting TLS handshake
 +;; - Server's trusted authorities:
 +;;    [0]: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
 +;; - Certificate type: X.509
 +;;  - Got a certificate list of 2 certificates.
 +;;
 +;;  - Certificate[0] info:
 +;;  # The hostname in the certificate matches 'yxa.extundo.com'.
 +;;  # valid since: Wed May 26 12:16:00 CEST 2004
 +;;  # expires at: Wed Jul 26 12:16:00 CEST 2023
 +;;  # serial number: 04
 +;;  # fingerprint: 7c 04 4b c1 fa 26 9b 5d 90 22 52 3c 65 3d 85 3a
 +;;  # version: #1
 +;;  # public key algorithm: RSA
 +;;  #   Modulus: 1024 bits
 +;;  # Subject's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=Mail server,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
 +;;  # Issuer's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
 +;;
 +;;  - Certificate[1] info:
 +;;  # valid since: Sun May 23 11:35:00 CEST 2004
 +;;  # expires at: Sun Jul 23 11:35:00 CEST 2023
 +;;  # serial number: 00
 +;;  # fingerprint: fc 76 d8 63 1a c9 0b 3b fa 40 fe ed 47 7a 58 ae
 +;;  # version: #3
 +;;  # public key algorithm: RSA
 +;;  #   Modulus: 1024 bits
 +;;  # Subject's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
 +;;  # Issuer's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
 +;;
 +;; - Peer's certificate issuer is unknown
 +;; - Peer's certificate is NOT trusted
 +;; - Version: TLS 1.0
 +;; - Key Exchange: RSA
 +;; - Cipher: ARCFOUR 128
 +;; - MAC: SHA
 +;; - Compression: NULL
 +
 +;;; Code:
 +
 +(defgroup starttls nil
 +  "Support for `Transport Layer Security' protocol."
 +  :version "21.1"
 +  :group 'mail)
 +
 +(defcustom starttls-gnutls-program "gnutls-cli"
 +  "Name of GnuTLS command line tool.
 +This program is used when GnuTLS is used, i.e. when
 +`starttls-use-gnutls' is non-nil."
 +  :version "22.1"
 +  :type 'string
 +  :group 'starttls)
 +
 +(defcustom starttls-program "starttls"
 +  "The program to run in a subprocess to open an TLSv1 connection.
 +This program is used when the `starttls' command is used,
 +i.e. when `starttls-use-gnutls' is nil."
 +  :type 'string
 +  :group 'starttls)
 +
 +(defcustom starttls-use-gnutls (not (executable-find starttls-program))
 +  "Whether to use GnuTLS instead of the `starttls' command."
 +  :version "22.1"
 +  :type 'boolean
 +  :group 'starttls)
 +
 +(defcustom starttls-extra-args nil
 +  "Extra arguments to `starttls-program'.
 +These apply when the `starttls' command is used, i.e. when
 +`starttls-use-gnutls' is nil."
 +  :type '(repeat string)
 +  :group 'starttls)
 +
 +(defcustom starttls-extra-arguments nil
 +  "Extra arguments to `starttls-gnutls-program'.
 +These apply when GnuTLS is used, i.e. when `starttls-use-gnutls' is non-nil.
 +
 +For example, non-TLS compliant servers may require
 +\(\"--protocols\" \"ssl3\").  Invoke \"gnutls-cli --help\" to
 +find out which parameters are available."
 +  :version "22.1"
 +  :type '(repeat string)
 +  :group 'starttls)
 +
 +(defcustom starttls-process-connection-type nil
 +  "Value for `process-connection-type' to use when starting STARTTLS process."
 +  :version "22.1"
 +  :type 'boolean
 +  :group 'starttls)
 +
 +(defcustom starttls-connect "- Simple Client Mode:\n\n"
 +  "Regular expression indicating successful connection.
 +The default is what GnuTLS's \"gnutls-cli\" outputs."
 +  ;; GnuTLS cli.c:main() prints this string when it is starting to run
 +  ;; in the application read/write phase.  If the logic, or the string
 +  ;; itself, is modified, this must be updated.
 +  :version "22.1"
 +  :type 'regexp
 +  :group 'starttls)
 +
 +(defcustom starttls-failure "\\*\\*\\* Handshake has failed"
 +  "Regular expression indicating failed TLS handshake.
 +The default is what GnuTLS's \"gnutls-cli\" outputs."
 +  ;; GnuTLS cli.c:do_handshake() prints this string on failure.  If the
 +  ;; logic, or the string itself, is modified, this must be updated.
 +  :version "22.1"
 +  :type 'regexp
 +  :group 'starttls)
 +
 +(defcustom starttls-success "- Compression: "
 +  "Regular expression indicating completed TLS handshakes.
 +The default is what GnuTLS's \"gnutls-cli\" outputs."
 +  ;; GnuTLS cli.c:do_handshake() calls, on success,
 +  ;; common.c:print_info(), that unconditionally print this string
 +  ;; last.  If that logic, or the string itself, is modified, this
 +  ;; must be updated.
 +  :version "22.1"
 +  :type 'regexp
 +  :group 'starttls)
 +
 +(defun starttls-negotiate-gnutls (process)
 +  "Negotiate TLS on PROCESS opened by `open-starttls-stream'.
 +This should typically only be done once.  It typically returns a
 +multi-line informational message with information about the
 +handshake, or nil on failure."
 +  (let (buffer info old-max done-ok done-bad)
 +    (if (null (setq buffer (process-buffer process)))
 +      ;; XXX How to remove/extract the TLS negotiation junk?
 +      (signal-process (process-id process) 'SIGALRM)
 +      (with-current-buffer buffer
 +      (save-excursion
 +        (setq old-max (goto-char (point-max)))
 +        (signal-process (process-id process) 'SIGALRM)
 +        (while (and (processp process)
 +                    (eq (process-status process) 'run)
 +                    (save-excursion
 +                      (goto-char old-max)
 +                      (not (or (setq done-ok (re-search-forward
 +                                              starttls-success nil t))
 +                               (setq done-bad (re-search-forward
 +                                               starttls-failure nil t))))))
 +          (accept-process-output process 1 100)
 +          (sit-for 0.1))
 +        (setq info (buffer-substring-no-properties old-max (point-max)))
 +        (delete-region old-max (point-max))
 +        (if (or (and done-ok (not done-bad))
 +                ;; Prevent mitm that fake success msg after failure msg.
 +                (and done-ok done-bad (< done-ok done-bad)))
 +            info
 +          (message "STARTTLS negotiation failed: %s" info)
 +          nil))))))
 +
 +(defun starttls-negotiate (process)
 +  (if starttls-use-gnutls
 +      (starttls-negotiate-gnutls process)
 +    (signal-process (process-id process) 'SIGALRM)))
 +
 +(defun starttls-open-stream-gnutls (name buffer host port)
 +  (message "Opening STARTTLS connection to `%s:%s'..." host port)
 +  (let* (done
 +       (old-max (with-current-buffer buffer (point-max)))
 +       (process-connection-type starttls-process-connection-type)
 +       (process (apply #'start-process name buffer
 +                       starttls-gnutls-program "-s" host
 +                       "-p" (if (integerp port)
 +                                (int-to-string port)
 +                              port)
 +                       starttls-extra-arguments)))
 +    (set-process-query-on-exit-flag process nil)
 +    (while (and (processp process)
 +              (eq (process-status process) 'run)
 +              (with-current-buffer buffer
 +                (goto-char old-max)
 +                (not (setq done (re-search-forward
 +                                 starttls-connect nil t)))))
 +      (accept-process-output process 0 100)
 +      (sit-for 0.1))
 +    (if done
 +      (with-current-buffer buffer
 +        (delete-region old-max done))
 +      (delete-process process)
 +      (setq process nil))
 +    (message "Opening STARTTLS connection to `%s:%s'...%s"
 +           host port (if done "done" "failed"))
 +    process))
 +
 +;;;###autoload
 +(defun starttls-open-stream (name buffer host port)
 +  "Open a TLS connection for a port to a host.
 +Returns a subprocess object to represent the connection.
 +Input and output work as for subprocesses; `delete-process' closes it.
 +Args are NAME BUFFER HOST PORT.
 +NAME is name for process.  It is modified if necessary to make it unique.
 +BUFFER is the buffer (or `buffer-name') to associate with the process.
 + Process output goes at end of that buffer, unless you specify
 + a filter function to handle the output.
 + BUFFER may be also nil, meaning that this process is not associated
 + with any buffer
 +Third arg is name of the host to connect to, or its IP address.
 +Fourth arg PORT is an integer specifying a port to connect to.
 +If `starttls-use-gnutls' is nil, this may also be a service name, but
 +GnuTLS requires a port number."
 +  (if starttls-use-gnutls
 +      (starttls-open-stream-gnutls name buffer host port)
 +    (message "Opening STARTTLS connection to `%s:%s'" host (format "%s" port))
 +    (let* ((process-connection-type starttls-process-connection-type)
 +         (process (apply #'start-process
 +                         name buffer starttls-program
 +                         host (format "%s" port)
 +                         starttls-extra-args)))
 +      (set-process-query-on-exit-flag process nil)
 +      process)))
 +
 +(defun starttls-available-p ()
 +  "Say whether the STARTTLS programs are available."
 +  (and (not (memq system-type '(windows-nt ms-dos)))
 +       (executable-find (if starttls-use-gnutls
 +                          starttls-gnutls-program
 +                        starttls-program))))
 +
 +(defalias 'starttls-any-program-available 'starttls-available-p)
 +(make-obsolete 'starttls-any-program-available 'starttls-available-p
 +             "2011-08-02")
 +
 +(provide 'starttls)
 +
 +;;; starttls.el ends here

diff --cc lisp/obsolete/tls.el
index fb7c20c843a55f9edceb6b913032c7aff42ba6a9,0000000000000000000000000000000000000000..d17ddad7ee50d89fb16c48214ee32614f31cc065
mode 100644,000000..100644
--- 1/lisp/obsolete/tls.el
--- /dev/null
+++ b/lisp/obsolete/tls.el
@@@ -1,302 -1,0 +1,302 @@@
- ;; Copyright (C) 1996-1999, 2002-2018 Free Software Foundation, Inc.
 +;;; tls.el --- TLS/SSL support via wrapper around GnuTLS
 +
++;; Copyright (C) 1996-1999, 2002-2019 Free Software Foundation, Inc.
 +
 +;; Author: Simon Josefsson <simon@josefsson.org>
 +;; Keywords: comm, tls, gnutls, ssl
 +;; Obsolete-since: 27.1
 +
 +;; This file is part of GNU Emacs.
 +
 +;; GNU Emacs is free software: you can redistribute it and/or modify
 +;; it under the terms of the GNU General Public License as published by
 +;; the Free Software Foundation, either version 3 of the License, or
 +;; (at your option) any later version.
 +
 +;; GNU Emacs is distributed in the hope that it will be useful,
 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +;; GNU General Public License for more details.
 +
 +;; You should have received a copy of the GNU General Public License
 +;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
 +
 +;;; Commentary:
 +
 +;; This package implements a simple wrapper around "gnutls-cli" to
 +;; make Emacs support TLS/SSL.
 +;;
 +;; Usage is the same as `open-network-stream', i.e.:
 +;;
 +;; (setq tmp (open-tls-stream "test" (current-buffer) "news.mozilla.org" 563))
 +;; ...
 +;; #<process test>
 +;; (process-send-string tmp "mode reader\n")
 +;; 200 secnews.netscape.com Netscape-Collabra/3.52 03615 NNRP ready ...
 +;; nil
 +;; (process-send-string tmp "quit\n")
 +;; 205
 +;; nil
 +
 +;; To use this package as a replacement for ssl.el by William M. Perry
 +;; <wmperry@cs.indiana.edu>, you need to evaluate the following:
 +;;
 +;; (defalias 'open-ssl-stream 'open-tls-stream)
 +
 +;;; Code:
 +
 +(require 'gnutls)
 +
 +(autoload 'format-spec "format-spec")
 +(autoload 'format-spec-make "format-spec")
 +
 +(defgroup tls nil
 +  "Transport Layer Security (TLS) parameters."
 +  :group 'comm)
 +
 +(defcustom tls-end-of-info
 +  (concat
 +   "\\("
 +   ;; `openssl s_client' regexp.  See ssl/ssl_txt.c lines 219-220.
 +   ;; According to apps/s_client.c line 1515 `---' is always the last
 +   ;; line that is printed by s_client before the real data.
 +   "^    Verify return code: .+\n---\n\\|"
 +   ;; `gnutls' regexp. See src/cli.c lines 721-.
 +   "^- Simple Client Mode:\n"
 +   "\\(\n\\|"                           ; ignore blank lines
 +   ;; According to GnuTLS v2.1.5 src/cli.c lines 640-650 and 705-715
 +   ;; in `main' the handshake will start after this message.  If the
 +   ;; handshake fails, the programs will abort.
 +   "^\\*\\*\\* Starting TLS handshake\n\\)*"
 +   "\\)")
 +  "Regexp matching end of TLS client informational messages.
 +Client data stream begins after the last character this matches.
 +The default matches the output of \"gnutls-cli\" (version 2.0.1)."
 +  :version "22.2"
 +  :type 'regexp
 +  :group 'tls)
 +
 +(defcustom tls-program
 +  '("gnutls-cli --x509cafile %t -p %p %h"
 +    "gnutls-cli --x509cafile %t -p %p %h --protocols ssl3")
 +  "List of strings containing commands to start TLS stream to a host.
 +Each entry in the list is tried until a connection is successful.
 +%h is replaced with the server hostname, %p with the port to
 +connect to, and %t with a file name containing trusted certificates.
 +The program should read input on stdin and write output to stdout.
 +
 +See `tls-checktrust' on how to check trusted root certs.
 +
 +Also see `tls-success' for what the program should output after
 +successful negotiation."
 +  :type
 +  '(choice
 +    (const :tag "Default list of commands"
 +         ("gnutls-cli --x509cafile %t -p %p %h"
 +          "gnutls-cli --x509cafile %t -p %p %h --protocols ssl3"))
 +    (list :tag "Choose commands"
 +        :value
 +        ("gnutls-cli --x509cafile %t -p %p %h"
 +         "gnutls-cli --x509cafile %t -p %p %h --protocols ssl3")
 +        (set :inline t
 +             ;; FIXME: add brief `:tag "..."' descriptions.
 +             ;; (repeat :inline t :tag "Other" (string))
 +             ;; No trust check:
 +             (const "gnutls-cli --insecure -p %p %h")
 +             (const "gnutls-cli --insecure -p %p %h --protocols ssl3"))
 +        (repeat :inline t :tag "Other" (string)))
 +    (list :tag "List of commands"
 +        (repeat :tag "Command" (string))))
 +  :version "26.1"                       ; remove s_client
 +  :group 'tls)
 +
 +(defcustom tls-process-connection-type nil
 +  "Value for `process-connection-type' to use when starting TLS process."
 +  :version "22.1"
 +  :type 'boolean
 +  :group 'tls)
 +
 +(defcustom tls-success "- Handshake was completed\\|SSL handshake has read "
 +  "Regular expression indicating completed TLS handshakes.
 +The default is what GnuTLS's \"gnutls-cli\" outputs."
 +;; or OpenSSL's \"openssl s_client\"
 +  :version "22.1"
 +  :type 'regexp
 +  :group 'tls)
 +
 +(defcustom tls-checktrust nil
 +  "Indicate if certificates should be checked against trusted root certs.
 +If this is `ask', the user can decide whether to accept an
 +untrusted certificate.  You may have to adapt `tls-program' in
 +order to make this feature work properly, i.e., to ensure that
 +the external program knows about the root certificates you
 +consider trustworthy, e.g.:
 +
 +\(setq tls-program
 +      \\='(\"gnutls-cli --x509cafile /etc/ssl/certs/ca-certificates.crt -p %p %h\"
 +      \"gnutls-cli --x509cafile /etc/ssl/certs/ca-certificates.crt -p %p %h --protocols ssl3\"))"
 +  :type '(choice (const :tag "Always" t)
 +               (const :tag "Never" nil)
 +               (const :tag "Ask" ask))
 +  :version "23.1" ;; No Gnus
 +  :group 'tls)
 +
 +(defcustom tls-untrusted
 +  "- Peer's certificate is NOT trusted\\|Verify return code: \\([^0] \\|.[^ ]\\)"
 +  "Regular expression indicating failure of TLS certificate verification.
 +The default is what GnuTLS's \"gnutls-cli\" returns in the event of
 +unsuccessful verification."
 +;; or OpenSSL's \"openssl s_client\"
 +  :type 'regexp
 +  :version "23.1" ;; No Gnus
 +  :group 'tls)
 +
 +(defcustom tls-hostmismatch
 +  "# The hostname in the certificate does NOT match"
 +  "Regular expression indicating a host name mismatch in certificate.
 +When the host name specified in the certificate doesn't match the
 +name of the host you are connecting to, gnutls-cli issues a
 +warning to this effect.  There is no such feature in openssl.  Set
 +this to nil if you want to ignore host name mismatches."
 +  :type 'regexp
 +  :version "23.1" ;; No Gnus
 +  :group 'tls)
 +
 +(defcustom tls-certtool-program "certtool"
 +  "Name of GnuTLS certtool.
 +Used by `tls-certificate-information'."
 +  :version "22.1"
 +  :type 'string
 +  :group 'tls)
 +
 +(defalias 'tls-format-message
 +  (if (fboundp 'format-message) 'format-message
 +    ;; for Emacs < 25, and XEmacs, don't worry about quote translation.
 +    'format))
 +
 +(defun tls-certificate-information (der)
 +  "Parse X.509 certificate in DER format into an assoc list."
 +  (let ((certificate (concat "-----BEGIN CERTIFICATE-----\n"
 +                           (base64-encode-string der)
 +                           "\n-----END CERTIFICATE-----\n"))
 +      (exit-code 0))
 +    (with-current-buffer (get-buffer-create " *certtool*")
 +      (erase-buffer)
 +      (insert certificate)
 +      (setq exit-code (condition-case ()
 +                        (call-process-region (point-min) (point-max)
 +                                             tls-certtool-program
 +                                             t (list (current-buffer) nil) t
 +                                             "--certificate-info")
 +                      (error -1)))
 +      (if (/= exit-code 0)
 +        nil
 +      (let ((vals nil))
 +        (goto-char (point-min))
 +        (while (re-search-forward "^\\([^:]+\\): \\(.*\\)" nil t)
 +          (push (cons (match-string 1) (match-string 2)) vals))
 +        (nreverse vals))))))
 +
 +(defun open-tls-stream (name buffer host port)
 +  "Open a TLS connection for a port to a host.
 +Returns a subprocess-object to represent the connection.
 +Input and output work as for subprocesses; `delete-process' closes it.
 +Args are NAME BUFFER HOST PORT.
 +NAME is name for process.  It is modified if necessary to make it unique.
 +BUFFER is the buffer (or buffer name) to associate with the process.
 + Process output goes at end of that buffer, unless you specify
 + a filter function to handle the output.
 + BUFFER may be also nil, meaning that this process is not associated
 + with any buffer
 +Third arg is name of the host to connect to, or its IP address.
 +Fourth arg PORT is an integer specifying a port to connect to."
 +  (let ((cmds tls-program)
 +      (use-temp-buffer (null buffer))
 +      process cmd done)
 +    (if use-temp-buffer
 +      (setq buffer (generate-new-buffer " TLS"))
 +      ;; BUFFER is a string but does not exist as a buffer object.
 +      (unless (and (get-buffer buffer)
 +                 (buffer-name (get-buffer buffer)))
 +      (generate-new-buffer buffer)))
 +    (with-current-buffer buffer
 +      (message "Opening TLS connection to `%s'..." host)
 +      (while (and (not done) (setq cmd (pop cmds)))
 +      (let ((process-connection-type tls-process-connection-type)
 +            (formatted-cmd
 +             (format-spec
 +              cmd
 +              (format-spec-make
 +                 ?t (car (gnutls-trustfiles))
 +               ?h host
 +               ?p (if (integerp port)
 +                      (int-to-string port)
 +                    port)))))
 +        (message "Opening TLS connection with `%s'..." formatted-cmd)
 +        (setq process (start-process
 +                       name buffer shell-file-name shell-command-switch
 +                       formatted-cmd))
 +        (while (and process
 +                    (memq (process-status process) '(open run))
 +                    (progn
 +                      (goto-char (point-min))
 +                      (not (setq done (re-search-forward
 +                                       tls-success nil t)))))
 +          (unless (accept-process-output process 1)
 +            (sit-for 1)))
 +        (message "Opening TLS connection with `%s'...%s" formatted-cmd
 +                 (if done "done" "failed"))
 +        (if (not done)
 +            (delete-process process)
 +          ;; advance point to after all informational messages that
 +          ;; `openssl s_client' and `gnutls' print
 +          (let ((start-of-data nil))
 +            (while
 +                (not (setq start-of-data
 +                           ;; the string matching `tls-end-of-info'
 +                           ;; might come in separate chunks from
 +                           ;; `accept-process-output', so start the
 +                           ;; search where `tls-success' ended
 +                           (save-excursion
 +                             (if (re-search-forward tls-end-of-info nil t)
 +                                 (match-end 0)))))
 +              (accept-process-output process 1))
 +            (if start-of-data
 +                ;; move point to start of client data
 +                (goto-char start-of-data)))
 +          (setq done process))))
 +      (when (and done
 +               (or
 +                (and tls-checktrust
 +                     (save-excursion
 +                       (goto-char (point-min))
 +                       (re-search-forward tls-untrusted nil t))
 +                     (or
 +                      (and (not (eq tls-checktrust 'ask))
 +                           (message "The certificate presented by `%s' is \
 +NOT trusted." host))
 +                      (not (yes-or-no-p
 +                            (tls-format-message "\
 +The certificate presented by `%s' is NOT trusted. Accept anyway? " host)))))
 +                (and tls-hostmismatch
 +                     (save-excursion
 +                       (goto-char (point-min))
 +                       (re-search-forward tls-hostmismatch nil t))
 +                     (not (yes-or-no-p
 +                           (format "Host name in certificate doesn't \
 +match `%s'. Connect anyway? " host))))))
 +      (setq done nil)
 +      (delete-process process))
 +      ;; Delete all the informational messages that could confuse
 +      ;; future uses of `buffer'.
 +      (delete-region (point-min) (point)))
 +    (message "Opening TLS connection to `%s'...%s"
 +           host (if done "done" "failed"))
 +    (when use-temp-buffer
 +      (if done (set-process-buffer process nil))
 +      (kill-buffer buffer))
 +    done))
 +
 +(provide 'tls)
 +
 +;;; tls.el ends here

diff --cc lisp/obsolete/tpu-edt.el
Simple merge

diff --cc lisp/obsolete/tpu-extras.el
Simple merge

diff --cc lisp/obsolete/vc-arch.el
Simple merge

diff --cc lisp/obsolete/vip.el
Simple merge

diff --cc lisp/obsolete/xesam.el
Simple merge

diff --cc lisp/org/ob-core.el
Simple merge

diff --cc lisp/org/ob-eval.el
Simple merge

diff --cc lisp/org/org-agenda.el
Simple merge

diff --cc lisp/org/org-attach.el
Simple merge

diff --cc lisp/org/org-clock.el
Simple merge

diff --cc lisp/org/org-ctags.el
Simple merge

diff --cc lisp/org/org-element.el
Simple merge

diff --cc lisp/org/org-footnote.el
Simple merge

diff --cc lisp/org/org-id.el
Simple merge

diff --cc lisp/org/org-indent.el
Simple merge

diff --cc lisp/org/org-macro.el
Simple merge

diff --cc lisp/org/org-macs.el
Simple merge

diff --cc lisp/org/org-pcomplete.el
Simple merge

diff --cc lisp/org/org-protocol.el
Simple merge

diff --cc lisp/org/org.el
Simple merge

diff --cc lisp/org/ox-html.el
Simple merge

diff --cc lisp/org/ox-odt.el
Simple merge

diff --cc lisp/org/ox-publish.el
Simple merge

diff --cc lisp/outline.el
Simple merge

diff --cc lisp/paren.el
Simple merge

diff --cc lisp/pcmpl-cvs.el
Simple merge

diff --cc lisp/pcmpl-gnu.el
Simple merge

diff --cc lisp/pcmpl-linux.el
Simple merge

diff --cc lisp/pcmpl-rpm.el
Simple merge

diff --cc lisp/pcmpl-unix.el
Simple merge

diff --cc lisp/pcomplete.el
Simple merge

diff --cc lisp/pixel-scroll.el
Simple merge

diff --cc lisp/play/bubbles.el
index 6379c708be5cd8ec2fc817956088119f856fbea6,8d161775ffd74c2c01605056ad9c59a159ebcf3e..239fbe4e07c54514ad34fd2248b945f92100d5cf
--- 1/lisp/play/bubbles.el
--- 2/lisp/play/bubbles.el
+++ b/lisp/play/bubbles.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; bubbles.el --- Puzzle game for Emacs
 +;;; bubbles.el --- Puzzle game for Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2007-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2007-2019 Free Software Foundation, Inc.
  
  ;; Author:      Ulf Jasper <ulf.jasper@web.de>
  ;; URL:         http://ulf.epplejasper.de/

diff --cc lisp/play/cookie1.el
Simple merge

diff --cc lisp/play/dunnet.el
Simple merge

diff --cc lisp/play/fortune.el
Simple merge

diff --cc lisp/play/gamegrid.el
index 79825c4aaa51e906a252ce0eed5e85e51fb1da0e,7999194207bc29e0138ebe08d666599a7b09df17..430a2071bf80f5569732684eb1f7480adf1fc6b5
--- 1/lisp/play/gamegrid.el
--- 2/lisp/play/gamegrid.el
+++ b/lisp/play/gamegrid.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; gamegrid.el --- library for implementing grid-based games on Emacs
 +;;; gamegrid.el --- library for implementing grid-based games on Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1997-1998, 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1997-1998, 2001-2019 Free Software Foundation, Inc.
  
  ;; Author: Glynn Clements <glynn@sensei.co.uk>
  ;; Version: 1.02

diff --cc lisp/play/gametree.el
Simple merge

diff --cc lisp/play/gomoku.el
Simple merge

diff --cc lisp/printing.el
index c1a73df14c15214de35568e53ae9e51a2f863670,d3240fe532c88a77d6c77336e14986cce573bbdf..27856eb09fcfc3ecfefee1ee98a553eef7f3a571
--- 1/lisp/printing.el
--- 2/lisp/printing.el
+++ b/lisp/printing.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; printing.el --- printing utilities
  
- ;; Copyright (C) 2000-2001, 2003-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2000-2001, 2003-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, print, PostScript
  ;; Version: 6.9.3
  ;; X-URL: http://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre

diff --cc lisp/profiler.el
Simple merge

diff --cc lisp/progmodes/ada-mode.el
Simple merge

diff --cc lisp/progmodes/antlr-mode.el
Simple merge

diff --cc lisp/progmodes/autoconf.el
Simple merge

diff --cc lisp/progmodes/bat-mode.el
Simple merge

diff --cc lisp/progmodes/bug-reference.el
Simple merge

diff --cc lisp/progmodes/cc-align.el
Simple merge

diff --cc lisp/progmodes/cc-cmds.el
Simple merge

diff --cc lisp/progmodes/cc-defs.el
Simple merge

diff --cc lisp/progmodes/cc-engine.el
Simple merge

diff --cc lisp/progmodes/cc-fonts.el
Simple merge

diff --cc lisp/progmodes/cc-langs.el
Simple merge

diff --cc lisp/progmodes/cc-mode.el
Simple merge

diff --cc lisp/progmodes/cc-vars.el
Simple merge

diff --cc lisp/progmodes/cmacexp.el
Simple merge

diff --cc lisp/progmodes/compile.el
Simple merge

diff --cc lisp/progmodes/cperl-mode.el
index f9c390cd729a78a186ac82723670825b82354682,f25e24ba717f51f65aef1597edb4560c6d15c532..b83947f90344970f24a8d134c22d7ffa30683a90
--- 1/lisp/progmodes/cperl-mode.el
--- 2/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; cperl-mode.el --- Perl code editing commands for Emacs
 +;;; cperl-mode.el --- Perl code editing commands for Emacs  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1985-1987, 1991-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1985-1987, 1991-2019 Free Software Foundation, Inc.
  
  ;; Author: Ilya Zakharevich
  ;;    Bob Olson

diff --cc lisp/progmodes/cpp.el
Simple merge

diff --cc lisp/progmodes/cwarn.el
Simple merge

diff --cc lisp/progmodes/ebnf-abn.el
index 66f1d398df403934e97796c34b2877e94ea2e977,ff18c968bfad1c0bd826c375c4c97abadaf0ab32..b8441a79d98997306491162f3b6e727f7f383d95
--- 1/lisp/progmodes/ebnf-abn.el
--- 2/lisp/progmodes/ebnf-abn.el
+++ b/lisp/progmodes/ebnf-abn.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-abn.el --- parser for ABNF (Augmented BNF)
  
- ;; Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.2
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-bnf.el
index 7defe9877b2fbbbd2a9cae2b523be434fad3395e,ed8419214ccc59d2366ca8a185b281e9acc63882..f28f49090d0b7c13c39b715de8362758795bbfb8
--- 1/lisp/progmodes/ebnf-bnf.el
--- 2/lisp/progmodes/ebnf-bnf.el
+++ b/lisp/progmodes/ebnf-bnf.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-bnf.el --- parser for EBNF
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.10
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-dtd.el
index 2dec3f9159b642e62f27ab39156de3892d31fe90,735ccbf593db580725f8d63a430285d3f1078420..98284faf2970d546d3945e78835d1c1acc7e361b
--- 1/lisp/progmodes/ebnf-dtd.el
--- 2/lisp/progmodes/ebnf-dtd.el
+++ b/lisp/progmodes/ebnf-dtd.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-dtd.el --- parser for DTD (Data Type Description for XML)
  
- ;; Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.1
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-ebx.el
index 0dc82fc3bff361bed7ccc6f57fd7c4703802efce,9261280be160a696666207315f0dfb5eeb486630..5f9f9b2c19714492035a4f32e2ac4a293c79a4a3
--- 1/lisp/progmodes/ebnf-ebx.el
--- 2/lisp/progmodes/ebnf-ebx.el
+++ b/lisp/progmodes/ebnf-ebx.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-ebx.el --- parser for EBNF used to specify XML (EBNFX)
  
- ;; Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2001-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.2
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-iso.el
index 06aaf8a3f5521a4b868fe9f688e8ca3e521044be,27457682e8b5d5001a777586f1897d37c72b1740..88644bbe89718d69fc0b508fbd98c0ff68e7337b
--- 1/lisp/progmodes/ebnf-iso.el
--- 2/lisp/progmodes/ebnf-iso.el
+++ b/lisp/progmodes/ebnf-iso.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-iso.el --- parser for ISO EBNF
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.9
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-otz.el
index 5857aa306bae33d5e991c7781a7733505baef84e,7b9bd33e4e1565108a907862e1c1932379f65672..cbc058e4767a0c75c523e1a61259a59525fb6ff5
--- 1/lisp/progmodes/ebnf-otz.el
--- 2/lisp/progmodes/ebnf-otz.el
+++ b/lisp/progmodes/ebnf-otz.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-otz.el --- syntactic chart OpTimiZer
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.0
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf-yac.el
index eac0bfc878aacc6df8e2863cc850c3c2a12ca2af,c667ed54d8ed62c9a0703a38e7598f6f5db89f9e..3365f647c78e897a06cdaae4ab31e66d37d7c78b
--- 1/lisp/progmodes/ebnf-yac.el
--- 2/lisp/progmodes/ebnf-yac.el
+++ b/lisp/progmodes/ebnf-yac.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; ebnf-yac.el --- parser for Yacc/Bison
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Old-Version: 1.4
  ;; Package: ebnf2ps

diff --cc lisp/progmodes/ebnf2ps.el
index e29eb74a05b7512a8423b2a36644fa7eacfe5c8f,770acc987f67f80ee5ef969d4f2de58e8eba0282..7e7efacf1e78e1580eb2b754100a019f770cca4a
--- 1/lisp/progmodes/ebnf2ps.el
--- 2/lisp/progmodes/ebnf2ps.el
+++ b/lisp/progmodes/ebnf2ps.el
@@@ -1,9 -1,9 +1,9 @@@
 -;;; ebnf2ps.el --- translate an EBNF to a syntactic chart on PostScript
 +;;; ebnf2ps.el --- translate an EBNF to a syntactic chart on PostScript  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, ebnf, PostScript
  ;; Version: 4.4
  ;; X-URL: http://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre

diff --cc lisp/progmodes/ebrowse.el
Simple merge

diff --cc lisp/progmodes/elisp-mode.el
Simple merge

diff --cc lisp/progmodes/etags.el
Simple merge

diff --cc lisp/progmodes/f90.el
Simple merge

diff --cc lisp/progmodes/flymake-proc.el
index e969c5d99208de0b99de36a6ccd6c192274832b0,673f83e3396c54757cba38f397fc3dc253266a6a..7cdbb266fe11323b322060c91797b5cd17f2d860
--- 1/lisp/progmodes/flymake-proc.el
--- 2/lisp/progmodes/flymake-proc.el
+++ b/lisp/progmodes/flymake-proc.el
@@@ -1,10 -1,10 +1,10 @@@
  ;;; flymake-proc.el --- Flymake backend for external tools  -*- lexical-binding: t; -*-
  
- ;; Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2003-2019 Free Software Foundation, Inc.
  
  ;; Author:  Pavel Kobyakov <pk_at_work@yahoo.com>
 -;; Maintainer: Leo Liu <sdl.web@gmail.com>
 -;; Version: 0.3
 +;; Maintainer: João Távora <joaotavora@gmail.com>
 +;; Version: 1.0
  ;; Keywords: c languages tools
  
  ;; This file is part of GNU Emacs.

diff --cc lisp/progmodes/flymake.el
index 7b100da42b8dd9676dfd1aa23716b4a1fe0c78b0,16d97b6ccafe770b2894bb3adc920eaf82b7eaf6..50a9880a14e59ba6eedf253bc16bcf9bc204f826
--- 1/lisp/progmodes/flymake.el
--- 2/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@@ -1,11 -1,10 +1,11 @@@
  ;;; flymake.el --- A universal on-the-fly syntax checker  -*- lexical-binding: t; -*-
  
- ;; Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2003-2019 Free Software Foundation, Inc.
  
  ;; Author:  Pavel Kobyakov <pk_at_work@yahoo.com>
 -;; Maintainer: Leo Liu <sdl.web@gmail.com>
 -;; Version: 0.3
 +;; Maintainer: João Távora <joaotavora@gmail.com>
 +;; Version: 1.0.3
 +;; Package-Requires: ((emacs "26.1"))
  ;; Keywords: c languages tools
  
  ;; This file is part of GNU Emacs.

diff --cc lisp/progmodes/fortran.el
Simple merge

diff --cc lisp/progmodes/gdb-mi.el
Simple merge

diff --cc lisp/progmodes/glasses.el
Simple merge

diff --cc lisp/progmodes/grep.el
Simple merge

diff --cc lisp/progmodes/gud.el
Simple merge

diff --cc lisp/progmodes/hideif.el
Simple merge

diff --cc lisp/progmodes/hideshow.el
Simple merge

diff --cc lisp/progmodes/idlw-help.el
Simple merge

diff --cc lisp/progmodes/idlw-shell.el
index 46e2ecaa397098d2669451c9bbdea3b6dd0b06df,883616cd28566cfe510e3a1432020134d2cd9e44..a3b079830b203d959d7a9d9515023db9f0927ca3
--- 1/lisp/progmodes/idlw-shell.el
--- 2/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@@ -1,6 -1,6 +1,6 @@@
 -;; idlw-shell.el --- run IDL as an inferior process of Emacs.
 +;; idlw-shell.el --- run IDL as an inferior process of Emacs.  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1999-2019 Free Software Foundation, Inc.
  
  ;; Authors: J.D. Smith <jdsmith@as.arizona.edu>
  ;;          Carsten Dominik <dominik@astro.uva.nl>

diff --cc lisp/progmodes/idlw-toolbar.el
Simple merge

diff --cc lisp/progmodes/idlwave.el
Simple merge

diff --cc lisp/progmodes/js.el
Simple merge

diff --cc lisp/progmodes/m4-mode.el
Simple merge

diff --cc lisp/progmodes/make-mode.el
Simple merge

diff --cc lisp/progmodes/mixal-mode.el
Simple merge

diff --cc lisp/progmodes/octave.el
Simple merge

diff --cc lisp/progmodes/opascal.el
Simple merge

diff --cc lisp/progmodes/pascal.el
Simple merge

diff --cc lisp/progmodes/perl-mode.el
Simple merge

diff --cc lisp/progmodes/prog-mode.el
Simple merge

diff --cc lisp/progmodes/project.el
Simple merge

diff --cc lisp/progmodes/prolog.el
Simple merge

diff --cc lisp/progmodes/ps-mode.el
Simple merge

diff --cc lisp/progmodes/python.el
Simple merge

diff --cc lisp/progmodes/ruby-mode.el
Simple merge

diff --cc lisp/progmodes/sh-script.el
Simple merge

diff --cc lisp/progmodes/sql.el
Simple merge

diff --cc lisp/progmodes/subword.el
Simple merge

diff --cc lisp/progmodes/tcl.el
Simple merge

diff --cc lisp/progmodes/verilog-mode.el
Simple merge

diff --cc lisp/progmodes/vhdl-mode.el
Simple merge

diff --cc lisp/progmodes/which-func.el
Simple merge

diff --cc lisp/progmodes/xref.el
Simple merge

diff --cc lisp/ps-bdf.el
Simple merge

diff --cc lisp/ps-def.el
index d0cd7625a41c484907750937ae6a83e6f245b7bd,e3c9504a01f85568a5aee6f46a7e6ca9240070e0..206313389028313fab5f00d3c96f3426e432ade4
--- 1/lisp/ps-def.el
--- 2/lisp/ps-def.el
+++ b/lisp/ps-def.el
@@@ -1,11 -1,11 +1,11 @@@
  ;;; ps-def.el --- XEmacs and Emacs definitions for ps-print -*- lexical-binding: t -*-
  
- ;; Copyright (C) 2007-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2007-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;;    Kenichi Handa <handa@m17n.org> (multi-byte characters)
  ;; Maintainer: Kenichi Handa <handa@m17n.org> (multi-byte characters)
 -;;    Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;;    Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, print, PostScript
  ;; X-URL: http://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre
  ;; Package: ps-print

diff --cc lisp/ps-mule.el
index 2658aec5e6de036fc2a78b97c11448b5f45ad71a,9a32b05526edc1bc4e6c7e221796c11f153ed2e4..c88d6d267977b898ca66988048a6073b995e97a4
--- 1/lisp/ps-mule.el
--- 2/lisp/ps-mule.el
+++ b/lisp/ps-mule.el
@@@ -1,11 -1,11 +1,11 @@@
  ;;; ps-mule.el --- provide multi-byte character facility to ps-print
  
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;;    Kenichi Handa <handa@m17n.org> (multi-byte characters)
  ;; Maintainer: Kenichi Handa <handa@m17n.org> (multi-byte characters)
 -;;    Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;;    Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: wp, print, PostScript, multibyte, mule
  ;; Package: ps-print
  

diff --cc lisp/ps-print.el
Simple merge

diff --cc lisp/ps-samp.el
Simple merge

diff --cc lisp/recentf.el
Simple merge

diff --cc lisp/rect.el
Simple merge

diff --cc lisp/register.el
Simple merge

diff --cc lisp/registry.el
Simple merge

diff --cc lisp/replace.el
Simple merge

diff --cc lisp/reveal.el
Simple merge

diff --cc lisp/rfn-eshadow.el
Simple merge

diff --cc lisp/rtree.el
index fe24cd187190c19477ae2f35e22b5d623b2b88b8,ff160f207b263bf7d695c80d8aba19b6206af059..9a0a649abf1bb74c701b81a6cc0ba47b7b5b505a
--- 1/lisp/rtree.el
--- 2/lisp/rtree.el
+++ b/lisp/rtree.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; rtree.el --- functions for manipulating range trees
 +;;; rtree.el --- functions for manipulating range trees  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 2010-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2010-2019 Free Software Foundation, Inc.
  
  ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
  

diff --cc lisp/ruler-mode.el
Simple merge

diff --cc lisp/savehist.el
Simple merge

diff --cc lisp/saveplace.el
Simple merge

diff --cc lisp/scroll-all.el
Simple merge

diff --cc lisp/scroll-bar.el
Simple merge

diff --cc lisp/scroll-lock.el
Simple merge

diff --cc lisp/select.el
Simple merge

diff --cc lisp/server.el
Simple merge

diff --cc lisp/ses.el
Simple merge

diff --cc lisp/shadowfile.el
Simple merge

diff --cc lisp/shell.el
Simple merge

diff --cc lisp/simple.el
Simple merge

diff --cc lisp/skeleton.el
Simple merge

diff --cc lisp/speedbar.el
Simple merge

diff --cc lisp/startup.el
Simple merge

diff --cc lisp/strokes.el
Simple merge

diff --cc lisp/subr.el
Simple merge

diff --cc lisp/svg.el
Simple merge

diff --cc lisp/t-mouse.el
Simple merge

diff --cc lisp/tar-mode.el
Simple merge

diff --cc lisp/term.el
index 9f8f1f703a6cd4b83d71dddb00f86a4b4f06a3f3,cbef68dc0aceb5dfc4390a67845c793152d62f2d..f49777f94c2ad80cd16482e779ce9a3400ddd348
--- 1/lisp/term.el
--- 2/lisp/term.el
+++ b/lisp/term.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; term.el --- general command interpreter in a window stuff
 +;;; term.el --- general command interpreter in a window stuff -*- lexical-binding: t -*-
  
- ;; Copyright (C) 1988, 1990, 1992, 1994-1995, 2001-2018 Free Software
+ ;; Copyright (C) 1988, 1990, 1992, 1994-1995, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Per Bothner <per@bothner.com>

diff --cc lisp/term/common-win.el
Simple merge

diff --cc lisp/term/internal.el
Simple merge

diff --cc lisp/term/ns-win.el
Simple merge

diff --cc lisp/term/pc-win.el
Simple merge

diff --cc lisp/term/sun.el
Simple merge

diff --cc lisp/term/tty-colors.el
Simple merge

diff --cc lisp/term/tvi970.el
Simple merge

diff --cc lisp/term/vt100.el
Simple merge

diff --cc lisp/term/w32-win.el
Simple merge

diff --cc lisp/term/x-win.el
Simple merge

diff --cc lisp/term/xterm.el
Simple merge

diff --cc lisp/textmodes/artist.el
Simple merge

diff --cc lisp/textmodes/bibtex.el
Simple merge

diff --cc lisp/textmodes/conf-mode.el
Simple merge

diff --cc lisp/textmodes/css-mode.el
Simple merge

diff --cc lisp/textmodes/dns-mode.el
Simple merge

diff --cc lisp/textmodes/enriched.el
Simple merge

diff --cc lisp/textmodes/fill.el
Simple merge

diff --cc lisp/textmodes/flyspell.el
Simple merge

diff --cc lisp/textmodes/ispell.el
Simple merge

diff --cc lisp/textmodes/mhtml-mode.el
Simple merge

diff --cc lisp/textmodes/nroff-mode.el
Simple merge

diff --cc lisp/textmodes/page-ext.el
index 92fce4d364b8eb1e2084a20219e4de8457186e79,a9199fffe0df67c1dfec28f3ccae15d528d684f2..23e2d28f77e7eb18a816b8f879eb03266ac46258
--- 1/lisp/textmodes/page-ext.el
--- 2/lisp/textmodes/page-ext.el
+++ b/lisp/textmodes/page-ext.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; page-ext.el --- extended page handling commands
 +;;; page-ext.el --- extended page handling commands  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1990-1991, 1993-1994, 2001-2018 Free Software
+ ;; Copyright (C) 1990-1991, 1993-1994, 2001-2019 Free Software
  ;; Foundation, Inc.
  
  ;; Author: Robert J. Chassell <bob@gnu.org>

diff --cc lisp/textmodes/paragraphs.el
Simple merge

diff --cc lisp/textmodes/refill.el
Simple merge

diff --cc lisp/textmodes/reftex-ref.el
Simple merge

diff --cc lisp/textmodes/reftex-vars.el
Simple merge

diff --cc lisp/textmodes/remember.el
Simple merge

diff --cc lisp/textmodes/rst.el
Simple merge

diff --cc lisp/textmodes/sgml-mode.el
Simple merge

diff --cc lisp/textmodes/tex-mode.el
Simple merge

diff --cc lisp/textmodes/texinfmt.el
Simple merge

diff --cc lisp/textmodes/texinfo.el
Simple merge

diff --cc lisp/thingatpt.el
Simple merge

diff --cc lisp/thumbs.el
Simple merge

diff --cc lisp/time.el
Simple merge

diff --cc lisp/tmm.el
Simple merge

diff --cc lisp/tool-bar.el
Simple merge

diff --cc lisp/tooltip.el
Simple merge

diff --cc lisp/tutorial.el
Simple merge

diff --cc lisp/type-break.el
Simple merge

diff --cc lisp/url/url-auth.el
Simple merge

diff --cc lisp/url/url-cache.el
Simple merge

diff --cc lisp/url/url-cookie.el
Simple merge

diff --cc lisp/url/url-dav.el
Simple merge

diff --cc lisp/url/url-dired.el
Simple merge

diff --cc lisp/url/url-file.el
index 02542ccbccc86046210895b8ac359867dd4624fd,23fc97828ffcdb64a0c5f28875af32f42c2ed9c8..b953ce7694083dc79498745c6df10a7b69dc83c8
--- 1/lisp/url/url-file.el
--- 2/lisp/url/url-file.el
+++ b/lisp/url/url-file.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; url-file.el --- File retrieval code
 +;;; url-file.el --- File retrieval code  -*- lexical-binding:t -*-
  
- ;; Copyright (C) 1996-1999, 2004-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1996-1999, 2004-2019 Free Software Foundation, Inc.
  
  ;; Keywords: comm, data, processes
  

diff --cc lisp/url/url-gw.el
Simple merge

diff --cc lisp/url/url-handlers.el
Simple merge

diff --cc lisp/url/url-http.el
Simple merge

diff --cc lisp/url/url-methods.el
Simple merge

diff --cc lisp/url/url-privacy.el
Simple merge

diff --cc lisp/url/url-queue.el
Simple merge

diff --cc lisp/url/url-util.el
Simple merge

diff --cc lisp/url/url-vars.el
Simple merge

diff --cc lisp/url/url.el
Simple merge

diff --cc lisp/userlock.el
Simple merge

diff --cc lisp/vc/add-log.el
Simple merge

diff --cc lisp/vc/cvs-status.el
Simple merge

diff --cc lisp/vc/diff-mode.el
Simple merge

diff --cc lisp/vc/diff.el
Simple merge

diff --cc lisp/vc/ediff-init.el
Simple merge

diff --cc lisp/vc/ediff-merg.el
Simple merge

diff --cc lisp/vc/ediff-ptch.el
Simple merge

diff --cc lisp/vc/ediff-util.el
Simple merge

diff --cc lisp/vc/ediff-wind.el
Simple merge

diff --cc lisp/vc/ediff.el
Simple merge

diff --cc lisp/vc/log-edit.el
Simple merge

diff --cc lisp/vc/log-view.el
Simple merge

diff --cc lisp/vc/pcvs-info.el
Simple merge

diff --cc lisp/vc/pcvs-parse.el
Simple merge

diff --cc lisp/vc/pcvs.el
Simple merge

diff --cc lisp/vc/smerge-mode.el
Simple merge

diff --cc lisp/vc/vc-bzr.el
Simple merge

diff --cc lisp/vc/vc-cvs.el
Simple merge

diff --cc lisp/vc/vc-dir.el
Simple merge

diff --cc lisp/vc/vc-dispatcher.el
Simple merge

diff --cc lisp/vc/vc-git.el
Simple merge

diff --cc lisp/vc/vc-hg.el
Simple merge

diff --cc lisp/vc/vc-hooks.el
Simple merge

diff --cc lisp/vc/vc-mtn.el
Simple merge

diff --cc lisp/vc/vc-rcs.el
Simple merge

diff --cc lisp/vc/vc-svn.el
Simple merge

diff --cc lisp/vc/vc.el
Simple merge

diff --cc lisp/vcursor.el
Simple merge

diff --cc lisp/version.el
Simple merge

diff --cc lisp/view.el
Simple merge

diff --cc lisp/w32-fns.el
Simple merge

diff --cc lisp/w32-vars.el
Simple merge

diff --cc lisp/wdired.el
Simple merge

diff --cc lisp/whitespace.el
index af06f7ccb14427383b5a7508bed02991dd5f89f5,79bc5c883489b22dc74ce6d1e0062f5a289a68d8..2463e655b19563b69b6bfb627d91a62c27d3ff94
--- 1/lisp/whitespace.el
--- 2/lisp/whitespace.el
+++ b/lisp/whitespace.el
@@@ -1,9 -1,9 +1,9 @@@
  ;;; whitespace.el --- minor mode to visualize TAB, (HARD) SPACE, NEWLINE -*- lexical-binding: t -*-
  
- ;; Copyright (C) 2000-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 2000-2019 Free Software Foundation, Inc.
  
 -;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 -;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 +;; Author: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
 +;; Maintainer: Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>
  ;; Keywords: data, wp
  ;; Version: 13.2.2
  ;; X-URL: http://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre

diff --cc lisp/wid-browse.el
Simple merge

diff --cc lisp/windmove.el
index 75b9e0cf5990283f4642a906d2b1d4f8075e9377,cf7b65a6ed78551633c46518cab1209d000459c9..65270d9bbe41c87e72c082fa2ae87ed1556e6a64
--- 1/lisp/windmove.el
--- 2/lisp/windmove.el
+++ b/lisp/windmove.el
@@@ -1,6 -1,6 +1,6 @@@
 -;;; windmove.el --- directional window-selection routines
 +;;; windmove.el --- directional window-selection routines  -*- lexical-binding:t -*-
  ;;
- ;; Copyright (C) 1998-2018 Free Software Foundation, Inc.
+ ;; Copyright (C) 1998-2019 Free Software Foundation, Inc.
  ;;
  ;; Author: Hovav Shacham (hovav@cs.stanford.edu)
  ;; Created: 17 October 1998

diff --cc lisp/window.el
Simple merge

diff --cc lisp/winner.el
Simple merge

diff --cc lisp/woman.el
Simple merge

diff --cc lisp/x-dnd.el
Simple merge

diff --cc lisp/xdg.el
Simple merge

diff --cc lisp/xml.el
Simple merge

diff --cc lisp/xt-mouse.el
Simple merge

diff --cc lwlib/Makefile.in
Simple merge

diff --cc m4/acl.m4
index b64aa849c8808f03fffdfacb8531755f5e4609e4,9ee7bbbde47bf2c41170f9958a88ea728d4cae4f..5234a80f93f8eb5b0635a98f466f177b069eefd6
--- 1/m4/acl.m4
--- 2/m4/acl.m4
+++ b/m4/acl.m4
@@@ -1,7 -1,7 +1,7 @@@
  # acl.m4 - check for access control list (ACL) primitives
 -# serial 22
 +# serial 23
  
- # Copyright (C) 2002, 2004-2018 Free Software Foundation, Inc.
+ # Copyright (C) 2002, 2004-2019 Free Software Foundation, Inc.
  # This file is free software; the Free Software Foundation
  # gives unlimited permission to copy and/or distribute it,
  # with or without modifications, as long as this notice is preserved.

diff --cc m4/c-strtod.m4
index 9282cee58e974d83e1638e9e70120b4e67d521fe,5b6e8297310578ab5fbf2a41555344da877c53e7..1694a2396c5b024ccf62f8c3613ef59a5e53e6be
--- 1/m4/c-strtod.m4
--- 2/m4/c-strtod.m4
+++ b/m4/c-strtod.m4
@@@ -1,6 -1,6 +1,6 @@@
 -# c-strtod.m4 serial 15
 +# c-strtod.m4 serial 16
  
- # Copyright (C) 2004-2006, 2009-2018 Free Software Foundation, Inc.
+ # Copyright (C) 2004-2006, 2009-2019 Free Software Foundation, Inc.
  # This file is free software; the Free Software Foundation
  # gives unlimited permission to copy and/or distribute it,
  # with or without modifications, as long as this notice is preserved.

diff --cc m4/extensions.m4
index 71a854f8bfaea77e3872f52b9097f26ad3838cbf,1a8e899d369e95042d7f3c6c878cdfbb17d7a0c8..fd1ce817f069f4841643f53e20ca060773b2ed6b
--- 1/m4/extensions.m4
--- 2/m4/extensions.m4
+++ b/m4/extensions.m4
@@@ -1,7 -1,7 +1,7 @@@
 -# serial 17  -*- Autoconf -*-
 +# serial 18  -*- Autoconf -*-
  # Enable extensions on systems that normally disable them.
  
- # Copyright (C) 2003, 2006-2018 Free Software Foundation, Inc.
+ # Copyright (C) 2003, 2006-2019 Free Software Foundation, Inc.
  # This file is free software; the Free Software Foundation
  # gives unlimited permission to copy and/or distribute it,
  # with or without modifications, as long as this notice is preserved.

diff --cc m4/extern-inline.m4
Simple merge

diff --cc m4/getgroups.m4
Simple merge

diff --cc m4/getloadavg.m4
Simple merge

diff --cc m4/gnulib-comp.m4
Simple merge

diff --cc m4/limits-h.m4
Simple merge

diff --cc m4/lstat.m4
index 3694e4ceaf74f594c7c7da147ba3d702c43c1341,ef6b457a94d6cce1269771815a2c53ccf0af98d7..ace163867e22731234fd80bead0caf5ed69d8200
--- 1/m4/lstat.m4
--- 2/m4/lstat.m4
+++ b/m4/lstat.m4
@@@ -1,6 -1,6 +1,6 @@@
 -# serial 31
 +# serial 32
  
- # Copyright (C) 1997-2001, 2003-2018 Free Software Foundation, Inc.
+ # Copyright (C) 1997-2001, 2003-2019 Free Software Foundation, Inc.
  #
  # This file is free software; the Free Software Foundation
  # gives unlimited permission to copy and/or distribute it,

diff --cc m4/pthread_sigmask.m4
Simple merge

diff --cc m4/std-gnu11.m4
Simple merge

diff --cc m4/symlink.m4
index afaa941744e7ebdb2c83150eae3e7239e8f0ea52,277614e044373a37d8163859191b67cccd451e5e..508e94dd41016cb8b743e8a62068bf836d07de13
--- 1/m4/symlink.m4
--- 2/m4/symlink.m4
+++ b/m4/symlink.m4
@@@ -1,7 -1,7 +1,7 @@@
 -# serial 7
 +# serial 8
  # See if we need to provide symlink replacement.
  
- dnl Copyright (C) 2009-2018 Free Software Foundation, Inc.
+ dnl Copyright (C) 2009-2019 Free Software Foundation, Inc.
  dnl This file is free software; the Free Software Foundation
  dnl gives unlimited permission to copy and/or distribute it,
  dnl with or without modifications, as long as this notice is preserved.

diff --cc m4/time_rz.m4
Simple merge

diff --cc m4/utimens.m4
Simple merge

diff --cc m4/vararrays.m4
Simple merge

diff --cc make-dist
Simple merge

diff --cc msdos/sed2v2.inp
Simple merge

diff --cc nextstep/Makefile.in
Simple merge

diff --cc nt/INSTALL
Simple merge

diff --cc nt/INSTALL.W64
Simple merge

diff --cc nt/README.W32
index f0147b4c68fe7da34f028ddabbb48997e2a8a35a,d9f7e23a184e31c65076c8c05816327df23258be..0fac1c32988f2ed838dc2bcfa04bdebb61feda82
--- 1/nt/README.W32
--- 2/nt/README.W32
+++ b/nt/README.W32
@@@ -1,7 -1,7 +1,7 @@@
- Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 2001-2019 Free Software Foundation, Inc.
  See the end of the file for license conditions.
  
 -              Emacs version 26.1.90 for MS-Windows
 +              Emacs version 27.0.50 for MS-Windows
  
    This README file describes how to set up and run a precompiled
    distribution of the latest version of GNU Emacs for MS-Windows.  You

diff --cc nt/gnulib-cfg.mk
Simple merge

diff --cc nt/inc/ms-w32.h
Simple merge

diff --cc oldXMenu/Makefile.in
Simple merge

diff --cc src/.gdbinit
Simple merge

diff --cc src/Makefile.in
Simple merge

diff --cc src/alloc.c
Simple merge

diff --cc src/atimer.c
Simple merge

diff --cc src/bidi.c
index a53a2295c0954c6b7eb9a9d482914d8d4658baf7,216279cbc3a197abd747584d869aca6cf6a7174e..a62b888432e697cd79a383c19b2911b7b4d93276
--- 1/src/bidi.c
--- 2/src/bidi.c
+++ b/src/bidi.c
@@@ -1,8 -1,6 +1,8 @@@
  /* Low-level bidirectional buffer/string-scanning functions for GNU Emacs.
 -   Copyright (C) 2000-2001, 2004-2005, 2009-2019 Free Software
 -   Foundation, Inc.
 +
- Copyright (C) 2000-2001, 2004-2005, 2009-2018 Free Software Foundation, Inc.
++Copyright (C) 2000-2001, 2004-2005, 2009-2019 Free Software Foundation, Inc.
 +
 +Author: Eli Zaretskii <eliz@gnu.org>
  
  This file is part of GNU Emacs.
  

diff --cc src/buffer.c
Simple merge

diff --cc src/buffer.h
Simple merge

diff --cc src/bytecode.c
Simple merge

diff --cc src/callint.c
Simple merge

diff --cc src/callproc.c
Simple merge

diff --cc src/casefiddle.c
Simple merge

diff --cc src/casetab.c
Simple merge

diff --cc src/category.c
Simple merge

diff --cc src/ccl.c
Simple merge

diff --cc src/character.c
Simple merge

diff --cc src/charset.c
Simple merge

diff --cc src/charset.h
Simple merge

diff --cc src/cmds.c
Simple merge

diff --cc src/coding.c
Simple merge

diff --cc src/coding.h
Simple merge

diff --cc src/composite.c
Simple merge

diff --cc src/composite.h
Simple merge

diff --cc src/conf_post.h
Simple merge

diff --cc src/data.c
Simple merge

diff --cc src/dbusbind.c
Simple merge

diff --cc src/decompress.c
Simple merge

diff --cc src/deps.mk
Simple merge

diff --cc src/dired.c
Simple merge

diff --cc src/dispextern.h
Simple merge

diff --cc src/dispnew.c
Simple merge

diff --cc src/disptab.h
Simple merge

diff --cc src/doc.c
Simple merge

diff --cc src/doprnt.c
Simple merge

diff --cc src/dosfns.c
Simple merge

diff --cc src/dynlib.c
Simple merge

diff --cc src/editfns.c
Simple merge

diff --cc src/emacs-module.c
Simple merge

diff --cc src/emacs.c
Simple merge

diff --cc src/eval.c
Simple merge

diff --cc src/fileio.c
Simple merge

diff --cc src/floatfns.c
Simple merge

diff --cc src/fns.c
Simple merge

diff --cc src/font.c
Simple merge

diff --cc src/font.h
Simple merge

diff --cc src/fontset.c
Simple merge

diff --cc src/frame.c
Simple merge

diff --cc src/frame.h
Simple merge

diff --cc src/fringe.c
Simple merge

diff --cc src/ftcrfont.c
Simple merge

diff --cc src/ftfont.c
Simple merge

diff --cc src/gfilenotify.c
Simple merge

diff --cc src/gmalloc.c
Simple merge

diff --cc src/gnutls.c
Simple merge

diff --cc src/gtkutil.c
Simple merge

diff --cc src/image.c
Simple merge

diff --cc src/indent.c
Simple merge

diff --cc src/inotify.c
Simple merge

diff --cc src/insdel.c
Simple merge

diff --cc src/intervals.c
Simple merge

diff --cc src/intervals.h
Simple merge

diff --cc src/keyboard.c
Simple merge

diff --cc src/keyboard.h
Simple merge

diff --cc src/keymap.c
Simple merge

diff --cc src/kqueue.c
Simple merge

diff --cc src/lastfile.c
Simple merge

diff --cc src/lcms.c
Simple merge

diff --cc src/lisp.h
Simple merge

diff --cc src/lread.c
Simple merge

diff --cc src/macfont.m
Simple merge

diff --cc src/macros.c
Simple merge

diff --cc src/marker.c
Simple merge

diff --cc src/menu.c
Simple merge

diff --cc src/menu.h
Simple merge

diff --cc src/minibuf.c
Simple merge

diff --cc src/msdos.c
Simple merge

diff --cc src/nsfns.m
Simple merge

diff --cc src/nsfont.m
Simple merge

diff --cc src/nsgui.h
Simple merge

diff --cc src/nsimage.m
Simple merge

diff --cc src/nsmenu.m
Simple merge

diff --cc src/nsselect.m
Simple merge

diff --cc src/nsterm.h
Simple merge

diff --cc src/nsterm.m
Simple merge

diff --cc src/print.c
Simple merge

diff --cc src/process.c
Simple merge

diff --cc src/process.h
Simple merge

diff --cc src/profiler.c
Simple merge

diff --cc src/puresize.h
Simple merge

diff --cc src/ralloc.c
Simple merge

diff --cc src/regex-emacs.c
index 5cb7bba158ef118b1bb33b77c933c6e59dbb2aa1,0000000000000000000000000000000000000000..b667a43a37f292e3fb51ca536b3682488903e693
mode 100644,000000..100644
--- 1/src/regex-emacs.c
--- /dev/null
+++ b/src/regex-emacs.c
@@@ -1,5094 -1,0 +1,5094 @@@
-    Copyright (C) 1993-2018 Free Software Foundation, Inc.
 +/* Emacs regular expression matching and search
 +
++   Copyright (C) 1993-2019 Free Software Foundation, Inc.
 +
 +   This program is free software; you can redistribute it and/or modify
 +   it under the terms of the GNU General Public License as published by
 +   the Free Software Foundation; either version 3, or (at your option)
 +   any later version.
 +
 +   This program is distributed in the hope that it will be useful,
 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +   GNU General Public License for more details.
 +
 +   You should have received a copy of the GNU General Public License
 +   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 +
 +/* TODO:
 +   - structure the opcode space into opcode+flag.
 +   - replace (succeed_n + jump_n + set_number_at) with something that doesn't
 +     need to modify the compiled regexp so that re_search can be reentrant.
 +   - get rid of on_failure_jump_smart by doing the optimization in re_comp
 +     rather than at run-time, so that re_search can be reentrant.
 +*/
 +
 +#include <config.h>
 +
 +#include "regex-emacs.h"
 +
 +#include <stdlib.h>
 +
 +#include "character.h"
 +#include "buffer.h"
 +#include "syntax.h"
 +#include "category.h"
 +
 +/* Maximum number of duplicates an interval can allow.  Some systems
 +   define this in other header files, but we want our value, so remove
 +   any previous define.  Repeat counts are stored in opcodes as 2-byte
 +   unsigned integers.  */
 +#ifdef RE_DUP_MAX
 +# undef RE_DUP_MAX
 +#endif
 +#define RE_DUP_MAX (0xffff)
 +
 +/* Make syntax table lookup grant data in gl_state.  */
 +#define SYNTAX(c) syntax_property (c, 1)
 +
 +/* Convert the pointer to the char to BEG-based offset from the start.  */
 +#define PTR_TO_OFFSET(d) POS_AS_IN_BUFFER (POINTER_TO_OFFSET (d))
 +/* Strings are 0-indexed, buffers are 1-indexed; pun on the boolean
 +   result to get the right base index.  */
 +#define POS_AS_IN_BUFFER(p)                                    \
 +  ((p) + (NILP (gl_state.object) || BUFFERP (gl_state.object)))
 +
 +#define RE_MULTIBYTE_P(bufp) ((bufp)->multibyte)
 +#define RE_TARGET_MULTIBYTE_P(bufp) ((bufp)->target_multibyte)
 +#define RE_STRING_CHAR(p, multibyte) \
 +  (multibyte ? STRING_CHAR (p) : *(p))
 +#define RE_STRING_CHAR_AND_LENGTH(p, len, multibyte) \
 +  (multibyte ? STRING_CHAR_AND_LENGTH (p, len) : ((len) = 1, *(p)))
 +
 +#define RE_CHAR_TO_MULTIBYTE(c) UNIBYTE_TO_CHAR (c)
 +
 +#define RE_CHAR_TO_UNIBYTE(c) CHAR_TO_BYTE_SAFE (c)
 +
 +/* Set C a (possibly converted to multibyte) character before P.  P
 +   points into a string which is the virtual concatenation of STR1
 +   (which ends at END1) or STR2 (which ends at END2).  */
 +#define GET_CHAR_BEFORE_2(c, p, str1, end1, str2, end2)                            \
 +  do {                                                                             \
 +    if (target_multibyte)                                                  \
 +      {                                                                            \
 +      re_char *dtemp = (p) == (str2) ? (end1) : (p);                       \
 +      re_char *dlimit = (p) > (str2) && (p) <= (end2) ? (str2) : (str1);   \
 +      while (dtemp-- > dlimit && !CHAR_HEAD_P (*dtemp))                    \
 +        continue;                                                          \
 +      c = STRING_CHAR (dtemp);                                             \
 +      }                                                                            \
 +    else                                                                   \
 +      {                                                                            \
 +      (c = ((p) == (str2) ? (end1) : (p))[-1]);                            \
 +      (c) = RE_CHAR_TO_MULTIBYTE (c);                                      \
 +      }                                                                            \
 +  } while (false)
 +
 +/* Set C a (possibly converted to multibyte) character at P, and set
 +   LEN to the byte length of that character.  */
 +#define GET_CHAR_AFTER(c, p, len)             \
 +  do {                                                \
 +    if (target_multibyte)                     \
 +      (c) = STRING_CHAR_AND_LENGTH (p, len);  \
 +    else                                      \
 +      {                                               \
 +      (c) = *p;                               \
 +      len = 1;                                \
 +      (c) = RE_CHAR_TO_MULTIBYTE (c);         \
 +      }                                               \
 +   } while (false)
 +\f
 +/* 1 if C is an ASCII character.  */
 +#define IS_REAL_ASCII(c) ((c) < 0200)
 +
 +/* 1 if C is a unibyte character.  */
 +#define ISUNIBYTE(c) (SINGLE_BYTE_CHAR_P ((c)))
 +
 +/* The Emacs definitions should not be directly affected by locales.  */
 +
 +/* In Emacs, these are only used for single-byte characters.  */
 +#define ISDIGIT(c) ((c) >= '0' && (c) <= '9')
 +#define ISCNTRL(c) ((c) < ' ')
 +#define ISXDIGIT(c) (0 <= char_hexdigit (c))
 +
 +/* The rest must handle multibyte characters.  */
 +
 +#define ISBLANK(c) (IS_REAL_ASCII (c)                 \
 +                     ? ((c) == ' ' || (c) == '\t')      \
 +                     : blankp (c))
 +
 +#define ISGRAPH(c) (SINGLE_BYTE_CHAR_P (c)                            \
 +                   ? (c) > ' ' && !((c) >= 0177 && (c) <= 0240)       \
 +                   : graphicp (c))
 +
 +#define ISPRINT(c) (SINGLE_BYTE_CHAR_P (c)                            \
 +                  ? (c) >= ' ' && !((c) >= 0177 && (c) <= 0237)       \
 +                   : printablep (c))
 +
 +#define ISALNUM(c) (IS_REAL_ASCII (c)                 \
 +                  ? (((c) >= 'a' && (c) <= 'z')       \
 +                     || ((c) >= 'A' && (c) <= 'Z')    \
 +                     || ((c) >= '0' && (c) <= '9'))   \
 +                  : alphanumericp (c))
 +
 +#define ISALPHA(c) (IS_REAL_ASCII (c)                 \
 +                  ? (((c) >= 'a' && (c) <= 'z')       \
 +                     || ((c) >= 'A' && (c) <= 'Z'))   \
 +                  : alphabeticp (c))
 +
 +#define ISLOWER(c) lowercasep (c)
 +
 +#define ISPUNCT(c) (IS_REAL_ASCII (c)                         \
 +                  ? ((c) > ' ' && (c) < 0177                  \
 +                     && !(((c) >= 'a' && (c) <= 'z')          \
 +                          || ((c) >= 'A' && (c) <= 'Z')       \
 +                          || ((c) >= '0' && (c) <= '9')))     \
 +                  : SYNTAX (c) != Sword)
 +
 +#define ISSPACE(c) (SYNTAX (c) == Swhitespace)
 +
 +#define ISUPPER(c) uppercasep (c)
 +
 +#define ISWORD(c) (SYNTAX (c) == Sword)
 +\f
 +#define SIGN_EXTEND_CHAR(c) ((signed char) (c))
 +\f
 +/* Use alloca instead of malloc.  This is because using malloc in
 +   re_search* or re_match* could cause memory leaks when C-g is used
 +   in Emacs (note that SAFE_ALLOCA could also call malloc, but does so
 +   via 'record_xmalloc' which uses 'unwind_protect' to ensure the
 +   memory is freed even in case of non-local exits); also, malloc is
 +   slower and causes storage fragmentation.  On the other hand, malloc
 +   is more portable, and easier to debug.
 +
 +   Because we sometimes use alloca, some routines have to be macros,
 +   not functions -- 'alloca'-allocated space disappears at the end of the
 +   function it is called in.  */
 +
 +/* This may be adjusted in main(), if the stack is successfully grown.  */
 +ptrdiff_t emacs_re_safe_alloca = MAX_ALLOCA;
 +/* Like USE_SAFE_ALLOCA, but use emacs_re_safe_alloca.  */
 +#define REGEX_USE_SAFE_ALLOCA                                        \
 +  USE_SAFE_ALLOCA; sa_avail = emacs_re_safe_alloca
 +
 +/* Assumes a 'char *destination' variable.  */
 +#define REGEX_REALLOCATE(source, osize, nsize)                                \
 +  (destination = SAFE_ALLOCA (nsize),                                 \
 +   memcpy (destination, source, osize))
 +
 +/* True if 'size1' is non-NULL and PTR is pointing anywhere inside
 +   'string1' or just past its end.  This works if PTR is NULL, which is
 +   a good thing.  */
 +#define FIRST_STRING_P(ptr)                                   \
 +  (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
 +
 +/* (Re)Allocate N items of type T using malloc, or fail.  */
 +#define TALLOC(n, t) ((t *) xmalloc ((n) * sizeof (t)))
 +#define RETALLOC(addr, n, t) ((addr) = (t *) xrealloc (addr, (n) * sizeof (t)))
 +
 +#define BYTEWIDTH 8 /* In bits.  */
 +
 +/* Type of source-pattern and string chars.  */
 +typedef const unsigned char re_char;
 +
 +static void re_compile_fastmap (struct re_pattern_buffer *);
 +static ptrdiff_t re_match_2_internal (struct re_pattern_buffer *bufp,
 +                                   re_char *string1, size_t size1,
 +                                   re_char *string2, size_t size2,
 +                                   ptrdiff_t pos,
 +                                   struct re_registers *regs,
 +                                   ptrdiff_t stop);
 +\f
 +/* These are the command codes that appear in compiled regular
 +   expressions.  Some opcodes are followed by argument bytes.  A
 +   command code can specify any interpretation whatsoever for its
 +   arguments.  Zero bytes may appear in the compiled regular expression.  */
 +
 +typedef enum
 +{
 +  no_op = 0,
 +
 +  /* Succeed right away--no more backtracking.  */
 +  succeed,
 +
 +      /* Followed by one byte giving n, then by n literal bytes.  */
 +  exactn,
 +
 +      /* Matches any (more or less) character.  */
 +  anychar,
 +
 +      /* Matches any one char belonging to specified set.  First
 +         following byte is number of bitmap bytes.  Then come bytes
 +         for a bitmap saying which chars are in.  Bits in each byte
 +         are ordered low-bit-first.  A character is in the set if its
 +         bit is 1.  A character too large to have a bit in the map is
 +         automatically not in the set.
 +
 +         If the length byte has the 0x80 bit set, then that stuff
 +         is followed by a range table:
 +             2 bytes of flags for character sets (low 8 bits, high 8 bits)
 +                 See RANGE_TABLE_WORK_BITS below.
 +             2 bytes, the number of pairs that follow (upto 32767)
 +             pairs, each 2 multibyte characters,
 +                 each multibyte character represented as 3 bytes.  */
 +  charset,
 +
 +      /* Same parameters as charset, but match any character that is
 +         not one of those specified.  */
 +  charset_not,
 +
 +      /* Start remembering the text that is matched, for storing in a
 +         register.  Followed by one byte with the register number, in
 +         the range 0 to one less than the pattern buffer's re_nsub
 +         field.  */
 +  start_memory,
 +
 +      /* Stop remembering the text that is matched and store it in a
 +         memory register.  Followed by one byte with the register
 +         number, in the range 0 to one less than 're_nsub' in the
 +         pattern buffer.  */
 +  stop_memory,
 +
 +      /* Match a duplicate of something remembered. Followed by one
 +         byte containing the register number.  */
 +  duplicate,
 +
 +      /* Fail unless at beginning of line.  */
 +  begline,
 +
 +      /* Fail unless at end of line.  */
 +  endline,
 +
 +      /* Succeeds if at beginning of buffer.  */
 +  begbuf,
 +
 +      /* Analogously, for end of buffer/string.  */
 +  endbuf,
 +
 +      /* Followed by two byte relative address to which to jump.  */
 +  jump,
 +
 +      /* Followed by two-byte relative address of place to resume at
 +         in case of failure.  */
 +  on_failure_jump,
 +
 +      /* Like on_failure_jump, but pushes a placeholder instead of the
 +         current string position when executed.  */
 +  on_failure_keep_string_jump,
 +
 +      /* Just like 'on_failure_jump', except that it checks that we
 +         don't get stuck in an infinite loop (matching an empty string
 +         indefinitely).  */
 +  on_failure_jump_loop,
 +
 +      /* Just like 'on_failure_jump_loop', except that it checks for
 +         a different kind of loop (the kind that shows up with non-greedy
 +         operators).  This operation has to be immediately preceded
 +         by a 'no_op'.  */
 +  on_failure_jump_nastyloop,
 +
 +      /* A smart 'on_failure_jump' used for greedy * and + operators.
 +         It analyzes the loop before which it is put and if the
 +         loop does not require backtracking, it changes itself to
 +         'on_failure_keep_string_jump' and short-circuits the loop,
 +         else it just defaults to changing itself into 'on_failure_jump'.
 +         It assumes that it is pointing to just past a 'jump'.  */
 +  on_failure_jump_smart,
 +
 +      /* Followed by two-byte relative address and two-byte number n.
 +         After matching N times, jump to the address upon failure.
 +         Does not work if N starts at 0: use on_failure_jump_loop
 +         instead.  */
 +  succeed_n,
 +
 +      /* Followed by two-byte relative address, and two-byte number n.
 +         Jump to the address N times, then fail.  */
 +  jump_n,
 +
 +      /* Set the following two-byte relative address to the
 +         subsequent two-byte number.  The address *includes* the two
 +         bytes of number.  */
 +  set_number_at,
 +
 +  wordbeg,    /* Succeeds if at word beginning.  */
 +  wordend,    /* Succeeds if at word end.  */
 +
 +  wordbound,  /* Succeeds if at a word boundary.  */
 +  notwordbound,       /* Succeeds if not at a word boundary.  */
 +
 +  symbeg,       /* Succeeds if at symbol beginning.  */
 +  symend,       /* Succeeds if at symbol end.  */
 +
 +      /* Matches any character whose syntax is specified.  Followed by
 +         a byte which contains a syntax code, e.g., Sword.  */
 +  syntaxspec,
 +
 +      /* Matches any character whose syntax is not that specified.  */
 +  notsyntaxspec,
 +
 +  at_dot,     /* Succeeds if at point.  */
 +
 +  /* Matches any character whose category-set contains the specified
 +     category.  The operator is followed by a byte which contains a
 +     category code (mnemonic ASCII character).  */
 +  categoryspec,
 +
 +  /* Matches any character whose category-set does not contain the
 +     specified category.  The operator is followed by a byte which
 +     contains the category code (mnemonic ASCII character).  */
 +  notcategoryspec
 +} re_opcode_t;
 +\f
 +/* Common operations on the compiled pattern.  */
 +
 +/* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
 +
 +#define STORE_NUMBER(destination, number)                             \
 +  do {                                                                        \
 +    (destination)[0] = (number) & 0377;                                       \
 +    (destination)[1] = (number) >> 8;                                 \
 +  } while (false)
 +
 +/* Same as STORE_NUMBER, except increment DESTINATION to
 +   the byte after where the number is stored.  Therefore, DESTINATION
 +   must be an lvalue.  */
 +
 +#define STORE_NUMBER_AND_INCR(destination, number)                    \
 +  do {                                                                        \
 +    STORE_NUMBER (destination, number);                                       \
 +    (destination) += 2;                                                       \
 +  } while (false)
 +
 +/* Put into DESTINATION a number stored in two contiguous bytes starting
 +   at SOURCE.  */
 +
 +#define EXTRACT_NUMBER(destination, source)                           \
 +  ((destination) = extract_number (source))
 +
 +static int
 +extract_number (re_char *source)
 +{
 +  unsigned leading_byte = SIGN_EXTEND_CHAR (source[1]);
 +  return (leading_byte << 8) + source[0];
 +}
 +
 +/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
 +   SOURCE must be an lvalue.  */
 +
 +#define EXTRACT_NUMBER_AND_INCR(destination, source)                  \
 +  ((destination) = extract_number_and_incr (&source))
 +
 +static int
 +extract_number_and_incr (re_char **source)
 +{
 +  int num = extract_number (*source);
 +  *source += 2;
 +  return num;
 +}
 +\f
 +/* Store a multibyte character in three contiguous bytes starting
 +   DESTINATION, and increment DESTINATION to the byte after where the
 +   character is stored.  Therefore, DESTINATION must be an lvalue.  */
 +
 +#define STORE_CHARACTER_AND_INCR(destination, character)      \
 +  do {                                                                \
 +    (destination)[0] = (character) & 0377;                    \
 +    (destination)[1] = ((character) >> 8) & 0377;             \
 +    (destination)[2] = (character) >> 16;                     \
 +    (destination) += 3;                                               \
 +  } while (false)
 +
 +/* Put into DESTINATION a character stored in three contiguous bytes
 +   starting at SOURCE.  */
 +
 +#define EXTRACT_CHARACTER(destination, source)        \
 +  do {                                                \
 +    (destination) = ((source)[0]              \
 +                   | ((source)[1] << 8)       \
 +                   | ((source)[2] << 16));    \
 +  } while (false)
 +
 +
 +/* Macros for charset. */
 +
 +/* Size of bitmap of charset P in bytes.  P is a start of charset,
 +   i.e. *P is (re_opcode_t) charset or (re_opcode_t) charset_not.  */
 +#define CHARSET_BITMAP_SIZE(p) ((p)[1] & 0x7F)
 +
 +/* Nonzero if charset P has range table.  */
 +#define CHARSET_RANGE_TABLE_EXISTS_P(p)        ((p)[1] & 0x80)
 +
 +/* Return the address of range table of charset P.  But not the start
 +   of table itself, but the before where the number of ranges is
 +   stored.  '2 +' means to skip re_opcode_t and size of bitmap,
 +   and the 2 bytes of flags at the start of the range table.  */
 +#define CHARSET_RANGE_TABLE(p) (&(p)[4 + CHARSET_BITMAP_SIZE (p)])
 +
 +/* Extract the bit flags that start a range table.  */
 +#define CHARSET_RANGE_TABLE_BITS(p)           \
 +  ((p)[2 + CHARSET_BITMAP_SIZE (p)]           \
 +   + (p)[3 + CHARSET_BITMAP_SIZE (p)] * 0x100)
 +
 +/* Return the address of end of RANGE_TABLE.  COUNT is number of
 +   ranges (which is a pair of (start, end)) in the RANGE_TABLE.  '* 2'
 +   is start of range and end of range.  '* 3' is size of each start
 +   and end.  */
 +#define CHARSET_RANGE_TABLE_END(range_table, count)   \
 +  ((range_table) + (count) * 2 * 3)
 +\f
 +/* If REGEX_EMACS_DEBUG is defined, print many voluminous messages
 +   (if the variable regex_emacs_debug is positive).  */
 +
 +#ifdef REGEX_EMACS_DEBUG
 +
 +/* Use standard I/O for debugging.  */
 +# include <stdio.h>
 +
 +static int regex_emacs_debug = -100000;
 +
 +# define DEBUG_STATEMENT(e) e
 +# define DEBUG_PRINT(...) if (regex_emacs_debug > 0) printf (__VA_ARGS__)
 +# define DEBUG_COMPILES_ARGUMENTS
 +# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)                                \
 +  if (regex_emacs_debug > 0) print_partial_compiled_pattern (s, e)
 +# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)                       \
 +  if (regex_emacs_debug > 0) print_double_string (w, s1, sz1, s2, sz2)
 +
 +
 +/* Print the fastmap in human-readable form.  */
 +
 +static void
 +print_fastmap (char *fastmap)
 +{
 +  unsigned was_a_range = 0;
 +  unsigned i = 0;
 +
 +  while (i < (1 << BYTEWIDTH))
 +    {
 +      if (fastmap[i++])
 +      {
 +        was_a_range = 0;
 +        putchar (i - 1);
 +        while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
 +          {
 +            was_a_range = 1;
 +            i++;
 +          }
 +        if (was_a_range)
 +          {
 +            printf ("-");
 +            putchar (i - 1);
 +          }
 +      }
 +    }
 +  putchar ('\n');
 +}
 +
 +
 +/* Print a compiled pattern string in human-readable form, starting at
 +   the START pointer into it and ending just before the pointer END.  */
 +
 +static void
 +print_partial_compiled_pattern (re_char *start, re_char *end)
 +{
 +  int mcnt, mcnt2;
 +  re_char *p = start;
 +  re_char *pend = end;
 +
 +  if (start == NULL)
 +    {
 +      fprintf (stderr, "(null)\n");
 +      return;
 +    }
 +
 +  /* Loop over pattern commands.  */
 +  while (p < pend)
 +    {
 +      fprintf (stderr, "%td:\t", p - start);
 +
 +      switch ((re_opcode_t) *p++)
 +      {
 +      case no_op:
 +        fprintf (stderr, "/no_op");
 +        break;
 +
 +      case succeed:
 +        fprintf (stderr, "/succeed");
 +        break;
 +
 +      case exactn:
 +        mcnt = *p++;
 +        fprintf (stderr, "/exactn/%d", mcnt);
 +        do
 +          {
 +            fprintf (stderr, "/%c", *p++);
 +          }
 +        while (--mcnt);
 +        break;
 +
 +      case start_memory:
 +        fprintf (stderr, "/start_memory/%d", *p++);
 +        break;
 +
 +      case stop_memory:
 +        fprintf (stderr, "/stop_memory/%d", *p++);
 +        break;
 +
 +      case duplicate:
 +        fprintf (stderr, "/duplicate/%d", *p++);
 +        break;
 +
 +      case anychar:
 +        fprintf (stderr, "/anychar");
 +        break;
 +
 +      case charset:
 +      case charset_not:
 +        {
 +          register int c, last = -100;
 +          register int in_range = 0;
 +          int length = CHARSET_BITMAP_SIZE (p - 1);
 +          int has_range_table = CHARSET_RANGE_TABLE_EXISTS_P (p - 1);
 +
 +          fprintf (stderr, "/charset [%s",
 +                   (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
 +
 +          if (p + *p >= pend)
 +            fprintf (stderr, " !extends past end of pattern! ");
 +
 +          for (c = 0; c < 256; c++)
 +            if (c / 8 < length
 +                && (p[1 + (c/8)] & (1 << (c % 8))))
 +              {
 +                /* Are we starting a range?  */
 +                if (last + 1 == c && ! in_range)
 +                  {
 +                    fprintf (stderr, "-");
 +                    in_range = 1;
 +                  }
 +                /* Have we broken a range?  */
 +                else if (last + 1 != c && in_range)
 +                  {
 +                    fprintf (stderr, "%c", last);
 +                    in_range = 0;
 +                  }
 +
 +                if (! in_range)
 +                  fprintf (stderr, "%c", c);
 +
 +                last = c;
 +            }
 +
 +          if (in_range)
 +            fprintf (stderr, "%c", last);
 +
 +          fprintf (stderr, "]");
 +
 +          p += 1 + length;
 +
 +          if (has_range_table)
 +            {
 +              int count;
 +              fprintf (stderr, "has-range-table");
 +
 +              /* ??? Should print the range table; for now, just skip it.  */
 +              p += 2;         /* skip range table bits */
 +              EXTRACT_NUMBER_AND_INCR (count, p);
 +              p = CHARSET_RANGE_TABLE_END (p, count);
 +            }
 +        }
 +        break;
 +
 +      case begline:
 +        fprintf (stderr, "/begline");
 +        break;
 +
 +      case endline:
 +        fprintf (stderr, "/endline");
 +        break;
 +
 +      case on_failure_jump:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/on_failure_jump to %td", p + mcnt - start);
 +        break;
 +
 +      case on_failure_keep_string_jump:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/on_failure_keep_string_jump to %td",
 +                 p + mcnt - start);
 +        break;
 +
 +      case on_failure_jump_nastyloop:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/on_failure_jump_nastyloop to %td",
 +                 p + mcnt - start);
 +        break;
 +
 +      case on_failure_jump_loop:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/on_failure_jump_loop to %td",
 +                 p + mcnt - start);
 +        break;
 +
 +      case on_failure_jump_smart:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/on_failure_jump_smart to %td",
 +                 p + mcnt - start);
 +        break;
 +
 +      case jump:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        fprintf (stderr, "/jump to %td", p + mcnt - start);
 +        break;
 +
 +      case succeed_n:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        EXTRACT_NUMBER_AND_INCR (mcnt2, p);
 +        fprintf (stderr, "/succeed_n to %td, %d times",
 +                 p - 2 + mcnt - start, mcnt2);
 +        break;
 +
 +      case jump_n:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        EXTRACT_NUMBER_AND_INCR (mcnt2, p);
 +        fprintf (stderr, "/jump_n to %td, %d times",
 +                 p - 2 + mcnt - start, mcnt2);
 +        break;
 +
 +      case set_number_at:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        EXTRACT_NUMBER_AND_INCR (mcnt2, p);
 +        fprintf (stderr, "/set_number_at location %td to %d",
 +                 p - 2 + mcnt - start, mcnt2);
 +        break;
 +
 +      case wordbound:
 +        fprintf (stderr, "/wordbound");
 +        break;
 +
 +      case notwordbound:
 +        fprintf (stderr, "/notwordbound");
 +        break;
 +
 +      case wordbeg:
 +        fprintf (stderr, "/wordbeg");
 +        break;
 +
 +      case wordend:
 +        fprintf (stderr, "/wordend");
 +        break;
 +
 +      case symbeg:
 +        fprintf (stderr, "/symbeg");
 +        break;
 +
 +      case symend:
 +        fprintf (stderr, "/symend");
 +        break;
 +
 +      case syntaxspec:
 +        fprintf (stderr, "/syntaxspec");
 +        mcnt = *p++;
 +        fprintf (stderr, "/%d", mcnt);
 +        break;
 +
 +      case notsyntaxspec:
 +        fprintf (stderr, "/notsyntaxspec");
 +        mcnt = *p++;
 +        fprintf (stderr, "/%d", mcnt);
 +        break;
 +
 +      case at_dot:
 +        fprintf (stderr, "/at_dot");
 +        break;
 +
 +      case categoryspec:
 +        fprintf (stderr, "/categoryspec");
 +        mcnt = *p++;
 +        fprintf (stderr, "/%d", mcnt);
 +        break;
 +
 +      case notcategoryspec:
 +        fprintf (stderr, "/notcategoryspec");
 +        mcnt = *p++;
 +        fprintf (stderr, "/%d", mcnt);
 +        break;
 +
 +      case begbuf:
 +        fprintf (stderr, "/begbuf");
 +        break;
 +
 +      case endbuf:
 +        fprintf (stderr, "/endbuf");
 +        break;
 +
 +      default:
 +        fprintf (stderr, "?%d", *(p-1));
 +      }
 +
 +      fprintf (stderr, "\n");
 +    }
 +
 +  fprintf (stderr, "%td:\tend of pattern.\n", p - start);
 +}
 +
 +
 +static void
 +print_compiled_pattern (struct re_pattern_buffer *bufp)
 +{
 +  re_char *buffer = bufp->buffer;
 +
 +  print_partial_compiled_pattern (buffer, buffer + bufp->used);
 +  printf ("%zu bytes used/%zu bytes allocated.\n",
 +        bufp->used, bufp->allocated);
 +
 +  if (bufp->fastmap_accurate && bufp->fastmap)
 +    {
 +      printf ("fastmap: ");
 +      print_fastmap (bufp->fastmap);
 +    }
 +
 +  printf ("re_nsub: %zu\t", bufp->re_nsub);
 +  printf ("regs_alloc: %d\t", bufp->regs_allocated);
 +  printf ("can_be_null: %d\t", bufp->can_be_null);
 +  fflush (stdout);
 +  /* Perhaps we should print the translate table?  */
 +}
 +
 +
 +static void
 +print_double_string (re_char *where, re_char *string1, ssize_t size1,
 +                   re_char *string2, ssize_t size2)
 +{
 +  ssize_t this_char;
 +
 +  if (where == NULL)
 +    printf ("(null)");
 +  else
 +    {
 +      if (FIRST_STRING_P (where))
 +      {
 +        for (this_char = where - string1; this_char < size1; this_char++)
 +          putchar (string1[this_char]);
 +
 +        where = string2;
 +      }
 +
 +      for (this_char = where - string2; this_char < size2; this_char++)
 +      putchar (string2[this_char]);
 +    }
 +}
 +
 +#else /* not REGEX_EMACS_DEBUG */
 +
 +# define DEBUG_STATEMENT(e)
 +# define DEBUG_PRINT(...)
 +# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
 +# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
 +
 +#endif /* not REGEX_EMACS_DEBUG */
 +\f
 +typedef enum
 +{
 +  REG_NOERROR = 0,    /* Success.  */
 +  REG_NOMATCH,                /* Didn't find a match (for regexec).  */
 +
 +  /* POSIX regcomp return error codes.  (In the order listed in the
 +     standard.)  An older version of this code supported the POSIX
 +     API; this version continues to use these names internally.  */
 +  REG_BADPAT,         /* Invalid pattern.  */
 +  REG_ECOLLATE,               /* Not implemented.  */
 +  REG_ECTYPE,         /* Invalid character class name.  */
 +  REG_EESCAPE,                /* Trailing backslash.  */
 +  REG_ESUBREG,                /* Invalid back reference.  */
 +  REG_EBRACK,         /* Unmatched left bracket.  */
 +  REG_EPAREN,         /* Parenthesis imbalance.  */
 +  REG_EBRACE,         /* Unmatched \{.  */
 +  REG_BADBR,          /* Invalid contents of \{\}.  */
 +  REG_ERANGE,         /* Invalid range end.  */
 +  REG_ESPACE,         /* Ran out of memory.  */
 +  REG_BADRPT,         /* No preceding re for repetition op.  */
 +
 +  /* Error codes we've added.  */
 +  REG_EEND,           /* Premature end.  */
 +  REG_ESIZE,          /* Compiled pattern bigger than 2^16 bytes.  */
 +  REG_ERPAREN,                /* Unmatched ) or \); not returned from regcomp.  */
 +  REG_ERANGEX,                /* Range striding over charsets.  */
 +  REG_ESIZEBR           /* n or m too big in \{n,m\} */
 +} reg_errcode_t;
 +
 +static const char *re_error_msgid[] =
 +  {
 +   [REG_NOERROR] = "Success",
 +   [REG_NOMATCH] = "No match",
 +   [REG_BADPAT] = "Invalid regular expression",
 +   [REG_ECOLLATE] = "Invalid collation character",
 +   [REG_ECTYPE] = "Invalid character class name",
 +   [REG_EESCAPE] = "Trailing backslash",
 +   [REG_ESUBREG] = "Invalid back reference",
 +   [REG_EBRACK] = "Unmatched [ or [^",
 +   [REG_EPAREN] = "Unmatched ( or \\(",
 +   [REG_EBRACE] = "Unmatched \\{",
 +   [REG_BADBR] = "Invalid content of \\{\\}",
 +   [REG_ERANGE] = "Invalid range end",
 +   [REG_ESPACE] = "Memory exhausted",
 +   [REG_BADRPT] = "Invalid preceding regular expression",
 +   [REG_EEND] = "Premature end of regular expression",
 +   [REG_ESIZE] = "Regular expression too big",
 +   [REG_ERPAREN] = "Unmatched ) or \\)",
 +   [REG_ERANGEX ] = "Range striding over charsets",
 +   [REG_ESIZEBR ] = "Invalid content of \\{\\}",
 +  };
 +
 +/* For 'regs_allocated'.  */
 +enum { REGS_UNALLOCATED, REGS_REALLOCATE, REGS_FIXED };
 +
 +/* If 'regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
 +   're_match_2' returns information about at least this many registers
 +   the first time a 'regs' structure is passed.  */
 +enum { RE_NREGS = 30 };
 +\f
 +/* The searching and matching functions allocate memory for the
 +   failure stack and registers.  Otherwise searching and matching
 +   routines would have much smaller memory resources at their
 +   disposal, and therefore might fail to handle complex regexps.  */
 +
 +/* Failure stack declarations and macros; both re_compile_fastmap and
 +   re_match_2 use a failure stack.  These have to be macros because of
 +   SAFE_ALLOCA.  */
 +
 +
 +/* Approximate number of failure points for which to initially allocate space
 +   when matching.  If this number is exceeded, we allocate more
 +   space, so it is not a hard limit.  */
 +#define INIT_FAILURE_ALLOC 20
 +
 +/* Roughly the maximum number of failure points on the stack.  Would be
 +   exactly that if failure always used TYPICAL_FAILURE_SIZE items.
 +   This is a variable only so users of regex can assign to it; we never
 +   change it ourselves.  We always multiply it by TYPICAL_FAILURE_SIZE
 +   before using it, so it should probably be a byte-count instead.  */
 +/* Note that 4400 was enough to cause a crash on Alpha OSF/1,
 +   whose default stack limit is 2mb.  In order for a larger
 +   value to work reliably, you have to try to make it accord
 +   with the process stack limit.  */
 +size_t emacs_re_max_failures = 40000;
 +
 +union fail_stack_elt
 +{
 +  re_char *pointer;
 +  /* This should be the biggest 'int' that's no bigger than a pointer.  */
 +  long integer;
 +};
 +
 +typedef union fail_stack_elt fail_stack_elt_t;
 +
 +typedef struct
 +{
 +  fail_stack_elt_t *stack;
 +  size_t size;
 +  size_t avail;       /* Offset of next open position.  */
 +  size_t frame;       /* Offset of the cur constructed frame.  */
 +} fail_stack_type;
 +
 +#define FAIL_STACK_EMPTY()     (fail_stack.frame == 0)
 +
 +
 +/* Define macros to initialize and free the failure stack.  */
 +
 +#define INIT_FAIL_STACK()                                             \
 +  do {                                                                        \
 +    fail_stack.stack =                                                        \
 +      SAFE_ALLOCA (INIT_FAILURE_ALLOC * TYPICAL_FAILURE_SIZE          \
 +                 * sizeof (fail_stack_elt_t));                        \
 +    fail_stack.size = INIT_FAILURE_ALLOC;                             \
 +    fail_stack.avail = 0;                                             \
 +    fail_stack.frame = 0;                                             \
 +  } while (false)
 +
 +
 +/* Double the size of FAIL_STACK, up to a limit
 +   which allows approximately 'emacs_re_max_failures' items.
 +
 +   Return 1 if succeeds, and 0 if either ran out of memory
 +   allocating space for it or it was already too large.
 +
 +   REGEX_REALLOCATE requires 'destination' be declared.   */
 +
 +/* Factor to increase the failure stack size by.
 +   This used to be 2, but 2 was too wasteful
 +   because the old discarded stacks added up to as much space
 +   were as ultimate, maximum-size stack.  */
 +#define FAIL_STACK_GROWTH_FACTOR 4
 +
 +#define GROW_FAIL_STACK(fail_stack)                                   \
 +  (((fail_stack).size >= emacs_re_max_failures * TYPICAL_FAILURE_SIZE)        \
 +   ? 0                                                                        \
 +   : ((fail_stack).stack                                              \
 +      = REGEX_REALLOCATE ((fail_stack).stack,                         \
 +        (fail_stack).size * sizeof (fail_stack_elt_t),                \
 +          min (emacs_re_max_failures * TYPICAL_FAILURE_SIZE,                  \
 +               ((fail_stack).size * FAIL_STACK_GROWTH_FACTOR))          \
 +          * sizeof (fail_stack_elt_t)),                                 \
 +      ((fail_stack).size                                              \
 +       = (min (emacs_re_max_failures * TYPICAL_FAILURE_SIZE,          \
 +             ((fail_stack).size * FAIL_STACK_GROWTH_FACTOR)))),       \
 +      1))
 +
 +
 +/* Push a pointer value onto the failure stack.
 +   Assumes the variable 'fail_stack'.  Probably should only
 +   be called from within 'PUSH_FAILURE_POINT'.  */
 +#define PUSH_FAILURE_POINTER(item)                                    \
 +  fail_stack.stack[fail_stack.avail++].pointer = (item)
 +
 +/* This pushes an integer-valued item onto the failure stack.
 +   Assumes the variable 'fail_stack'.  Probably should only
 +   be called from within 'PUSH_FAILURE_POINT'.  */
 +#define PUSH_FAILURE_INT(item)                                        \
 +  fail_stack.stack[fail_stack.avail++].integer = (item)
 +
 +/* These POP... operations complement the PUSH... operations.
 +   All assume that 'fail_stack' is nonempty.  */
 +#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
 +#define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
 +
 +/* Individual items aside from the registers.  */
 +#define NUM_NONREG_ITEMS 3
 +
 +/* Used to examine the stack (to detect infinite loops).  */
 +#define FAILURE_PAT(h) fail_stack.stack[(h) - 1].pointer
 +#define FAILURE_STR(h) (fail_stack.stack[(h) - 2].pointer)
 +#define NEXT_FAILURE_HANDLE(h) fail_stack.stack[(h) - 3].integer
 +#define TOP_FAILURE_HANDLE() fail_stack.frame
 +
 +
 +#define ENSURE_FAIL_STACK(space)                                      \
 +while (REMAINING_AVAIL_SLOTS <= space) {                              \
 +  if (!GROW_FAIL_STACK (fail_stack))                                  \
 +    return -2;                                                                \
 +  DEBUG_PRINT ("\n  Doubled stack; size now: %zu\n", (fail_stack).size);\
 +  DEBUG_PRINT ("       slots available: %zu\n", REMAINING_AVAIL_SLOTS);\
 +}
 +
 +/* Push register NUM onto the stack.  */
 +#define PUSH_FAILURE_REG(num)                                         \
 +do {                                                                  \
 +  char *destination;                                                  \
 +  long n = num;                                                               \
 +  ENSURE_FAIL_STACK(3);                                                       \
 +  DEBUG_PRINT ("    Push reg %ld (spanning %p -> %p)\n",              \
 +             n, regstart[n], regend[n]);                              \
 +  PUSH_FAILURE_POINTER (regstart[n]);                                 \
 +  PUSH_FAILURE_POINTER (regend[n]);                                   \
 +  PUSH_FAILURE_INT (n);                                                       \
 +} while (false)
 +
 +/* Change the counter's value to VAL, but make sure that it will
 +   be reset when backtracking.  */
 +#define PUSH_NUMBER(ptr,val)                                          \
 +do {                                                                  \
 +  char *destination;                                                  \
 +  int c;                                                              \
 +  ENSURE_FAIL_STACK(3);                                                       \
 +  EXTRACT_NUMBER (c, ptr);                                            \
 +  DEBUG_PRINT ("    Push number %p = %d -> %d\n", ptr, c, val);               \
 +  PUSH_FAILURE_INT (c);                                                       \
 +  PUSH_FAILURE_POINTER (ptr);                                         \
 +  PUSH_FAILURE_INT (-1);                                              \
 +  STORE_NUMBER (ptr, val);                                            \
 +} while (false)
 +
 +/* Pop a saved register off the stack.  */
 +#define POP_FAILURE_REG_OR_COUNT()                                    \
 +do {                                                                  \
 +  long pfreg = POP_FAILURE_INT ();                                    \
 +  if (pfreg == -1)                                                    \
 +    {                                                                 \
 +      /* It's a counter.  */                                          \
 +      /* Discard 'const', making re_search non-reentrant.  */         \
 +      unsigned char *ptr = (unsigned char *) POP_FAILURE_POINTER ();  \
 +      pfreg = POP_FAILURE_INT ();                                     \
 +      STORE_NUMBER (ptr, pfreg);                                      \
 +      DEBUG_PRINT ("     Pop counter %p = %ld\n", ptr, pfreg);                \
 +    }                                                                 \
 +  else                                                                        \
 +    {                                                                 \
 +      regend[pfreg] = POP_FAILURE_POINTER ();                         \
 +      regstart[pfreg] = POP_FAILURE_POINTER ();                               \
 +      DEBUG_PRINT ("     Pop reg %ld (spanning %p -> %p)\n",          \
 +                 pfreg, regstart[pfreg], regend[pfreg]);              \
 +    }                                                                 \
 +} while (false)
 +
 +/* Check that we are not stuck in an infinite loop.  */
 +#define CHECK_INFINITE_LOOP(pat_cur, string_place)                    \
 +do {                                                                  \
 +  ptrdiff_t failure = TOP_FAILURE_HANDLE ();                          \
 +  /* Check for infinite matching loops */                             \
 +  while (failure > 0                                                  \
 +       && (FAILURE_STR (failure) == string_place                      \
 +           || FAILURE_STR (failure) == NULL))                         \
 +    {                                                                 \
 +      eassert (FAILURE_PAT (failure) >= bufp->buffer                  \
 +             && FAILURE_PAT (failure) <= bufp->buffer + bufp->used);  \
 +      if (FAILURE_PAT (failure) == pat_cur)                           \
 +      {                                                               \
 +        cycle = 1;                                                    \
 +        break;                                                        \
 +      }                                                               \
 +      DEBUG_PRINT ("  Other pattern: %p\n", FAILURE_PAT (failure));   \
 +      failure = NEXT_FAILURE_HANDLE(failure);                         \
 +    }                                                                 \
 +  DEBUG_PRINT ("  Other string: %p\n", FAILURE_STR (failure));                \
 +} while (false)
 +
 +/* Push the information about the state we will need
 +   if we ever fail back to it.
 +
 +   Requires variables fail_stack, regstart, regend and
 +   num_regs be declared.  GROW_FAIL_STACK requires 'destination' be
 +   declared.
 +
 +   Does 'return FAILURE_CODE' if runs out of memory.  */
 +
 +#define PUSH_FAILURE_POINT(pattern, string_place)                     \
 +do {                                                                  \
 +  char *destination;                                                  \
 +  DEBUG_STATEMENT (nfailure_points_pushed++);                         \
 +  DEBUG_PRINT ("\nPUSH_FAILURE_POINT:\n");                            \
 +  DEBUG_PRINT ("  Before push, next avail: %zu\n", (fail_stack).avail);       \
 +  DEBUG_PRINT ("                      size: %zu\n", (fail_stack).size);\
 +                                                                      \
 +  ENSURE_FAIL_STACK (NUM_NONREG_ITEMS);                                       \
 +                                                                      \
 +  DEBUG_PRINT ("\n");                                                 \
 +                                                                      \
 +  DEBUG_PRINT ("  Push frame index: %zu\n", fail_stack.frame);                \
 +  PUSH_FAILURE_INT (fail_stack.frame);                                        \
 +                                                                      \
 +  DEBUG_PRINT ("  Push string %p: \"", string_place);                 \
 +  DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, size2);\
 +  DEBUG_PRINT ("\"\n");                                                       \
 +  PUSH_FAILURE_POINTER (string_place);                                        \
 +                                                                      \
 +  DEBUG_PRINT ("  Push pattern %p: ", pattern);                               \
 +  DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern, pend);                 \
 +  PUSH_FAILURE_POINTER (pattern);                                     \
 +                                                                      \
 +  /* Close the frame by moving the frame pointer past it.  */         \
 +  fail_stack.frame = fail_stack.avail;                                        \
 +} while (false)
 +
 +/* Estimate the size of data pushed by a typical failure stack entry.
 +   An estimate is all we need, because all we use this for
 +   is to choose a limit for how big to make the failure stack.  */
 +/* BEWARE, the value `20' is hard-coded in emacs.c:main().  */
 +#define TYPICAL_FAILURE_SIZE 20
 +
 +/* How many items can still be added to the stack without overflowing it.  */
 +#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)
 +
 +
 +/* Pop what PUSH_FAIL_STACK pushes.
 +
 +   Restore into the parameters, all of which should be lvalues:
 +     STR -- the saved data position.
 +     PAT -- the saved pattern position.
 +     REGSTART, REGEND -- arrays of string positions.
 +
 +   Also assume the variables FAIL_STACK and (if debugging) BUFP, PEND,
 +   STRING1, SIZE1, STRING2, and SIZE2.  */
 +
 +#define POP_FAILURE_POINT(str, pat)                                     \
 +do {                                                                  \
 +  eassert (!FAIL_STACK_EMPTY ());                                     \
 +                                                                      \
 +  /* Remove failure points and point to how many regs pushed.  */     \
 +  DEBUG_PRINT ("POP_FAILURE_POINT:\n");                                       \
 +  DEBUG_PRINT ("  Before pop, next avail: %zu\n", fail_stack.avail);  \
 +  DEBUG_PRINT ("                   size: %zu\n", fail_stack.size);    \
 +                                                                      \
 +  /* Pop the saved registers.  */                                     \
 +  while (fail_stack.frame < fail_stack.avail)                         \
 +    POP_FAILURE_REG_OR_COUNT ();                                      \
 +                                                                      \
 +  pat = POP_FAILURE_POINTER ();                                               \
 +  DEBUG_PRINT ("  Popping pattern %p: ", pat);                                \
 +  DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);                     \
 +                                                                      \
 +  /* If the saved string location is NULL, it came from an            \
 +     on_failure_keep_string_jump opcode, and we want to throw away the        \
 +     saved NULL, thus retaining our current position in the string.  */       \
 +  str = POP_FAILURE_POINTER ();                                               \
 +  DEBUG_PRINT ("  Popping string %p: \"", str);                               \
 +  DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);    \
 +  DEBUG_PRINT ("\"\n");                                                       \
 +                                                                      \
 +  fail_stack.frame = POP_FAILURE_INT ();                              \
 +  DEBUG_PRINT ("  Popping  frame index: %zu\n", fail_stack.frame);    \
 +                                                                      \
 +  eassert (fail_stack.avail >= 0);                                    \
 +  eassert (fail_stack.frame <= fail_stack.avail);                     \
 +                                                                      \
 +  DEBUG_STATEMENT (nfailure_points_popped++);                         \
 +} while (false) /* POP_FAILURE_POINT */
 +
 +
 +\f
 +/* Registers are set to a sentinel when they haven't yet matched.  */
 +#define REG_UNSET(e) ((e) == NULL)
 +\f
 +/* Subroutine declarations and macros for regex_compile.  */
 +
 +static reg_errcode_t regex_compile (re_char *pattern, size_t size,
 +                                  bool posix_backtracking,
 +                                  const char *whitespace_regexp,
 +                                  struct re_pattern_buffer *bufp);
 +static void store_op1 (re_opcode_t op, unsigned char *loc, int arg);
 +static void store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2);
 +static void insert_op1 (re_opcode_t op, unsigned char *loc,
 +                      int arg, unsigned char *end);
 +static void insert_op2 (re_opcode_t op, unsigned char *loc,
 +                      int arg1, int arg2, unsigned char *end);
 +static bool at_begline_loc_p (re_char *pattern, re_char *p);
 +static bool at_endline_loc_p (re_char *p, re_char *pend);
 +static re_char *skip_one_char (re_char *p);
 +static int analyze_first (re_char *p, re_char *pend,
 +                        char *fastmap, const int multibyte);
 +
 +/* Fetch the next character in the uncompiled pattern, with no
 +   translation.  */
 +#define PATFETCH(c)                                                   \
 +  do {                                                                        \
 +    int len;                                                          \
 +    if (p == pend) return REG_EEND;                                   \
 +    c = RE_STRING_CHAR_AND_LENGTH (p, len, multibyte);                        \
 +    p += len;                                                         \
 +  } while (false)
 +
 +
 +#define RE_TRANSLATE(TBL, C) char_table_translate (TBL, C)
 +#define TRANSLATE(d) (!NILP (translate) ? RE_TRANSLATE (translate, d) : (d))
 +
 +/* Macros for outputting the compiled pattern into 'buffer'.  */
 +
 +/* If the buffer isn't allocated when it comes in, use this.  */
 +#define INIT_BUF_SIZE  32
 +
 +/* Ensure at least N more bytes of space in buffer.  */
 +#define GET_BUFFER_SPACE(n)                                           \
 +    while ((size_t) (b - bufp->buffer + (n)) > bufp->allocated)               \
 +      EXTEND_BUFFER ()
 +
 +/* Ensure one more byte of buffer space and then add C to it.  */
 +#define BUF_PUSH(c)                                                   \
 +  do {                                                                        \
 +    GET_BUFFER_SPACE (1);                                             \
 +    *b++ = (unsigned char) (c);                                               \
 +  } while (false)
 +
 +
 +/* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
 +#define BUF_PUSH_2(c1, c2)                                            \
 +  do {                                                                        \
 +    GET_BUFFER_SPACE (2);                                             \
 +    *b++ = (unsigned char) (c1);                                      \
 +    *b++ = (unsigned char) (c2);                                      \
 +  } while (false)
 +
 +
 +/* Store a jump with opcode OP at LOC to location TO.  Store a
 +   relative address offset by the three bytes the jump itself occupies.  */
 +#define STORE_JUMP(op, loc, to) \
 +  store_op1 (op, loc, (to) - (loc) - 3)
 +
 +/* Likewise, for a two-argument jump.  */
 +#define STORE_JUMP2(op, loc, to, arg) \
 +  store_op2 (op, loc, (to) - (loc) - 3, arg)
 +
 +/* Like 'STORE_JUMP', but for inserting.  Assume B is the buffer end.  */
 +#define INSERT_JUMP(op, loc, to) \
 +  insert_op1 (op, loc, (to) - (loc) - 3, b)
 +
 +/* Like 'STORE_JUMP2', but for inserting.  Assume B is the buffer end.  */
 +#define INSERT_JUMP2(op, loc, to, arg) \
 +  insert_op2 (op, loc, (to) - (loc) - 3, arg, b)
 +
 +
 +/* This is not an arbitrary limit: the arguments which represent offsets
 +   into the pattern are two bytes long.  So if 2^15 bytes turns out to
 +   be too small, many things would have to change.  */
 +# define MAX_BUF_SIZE (1 << 15)
 +
 +/* Extend the buffer by twice its current size via realloc and
 +   reset the pointers that pointed into the old block to point to the
 +   correct places in the new one.  If extending the buffer results in it
 +   being larger than MAX_BUF_SIZE, then flag memory exhausted.  */
 +#define EXTEND_BUFFER()                                                       \
 +  do {                                                                        \
 +    unsigned char *old_buffer = bufp->buffer;                         \
 +    if (bufp->allocated == MAX_BUF_SIZE)                              \
 +      return REG_ESIZE;                                                       \
 +    bufp->allocated <<= 1;                                            \
 +    if (bufp->allocated > MAX_BUF_SIZE)                                       \
 +      bufp->allocated = MAX_BUF_SIZE;                                 \
 +    ptrdiff_t b_off = b - old_buffer;                                 \
 +    ptrdiff_t begalt_off = begalt - old_buffer;                               \
 +    bool fixup_alt_jump_set = !!fixup_alt_jump;                               \
 +    bool laststart_set = !!laststart;                                 \
 +    bool pending_exact_set = !!pending_exact;                         \
 +    ptrdiff_t fixup_alt_jump_off, laststart_off, pending_exact_off;   \
 +    if (fixup_alt_jump_set) fixup_alt_jump_off = fixup_alt_jump - old_buffer; \
 +    if (laststart_set) laststart_off = laststart - old_buffer;                \
 +    if (pending_exact_set) pending_exact_off = pending_exact - old_buffer; \
 +    RETALLOC (bufp->buffer, bufp->allocated, unsigned char);          \
 +    unsigned char *new_buffer = bufp->buffer;                         \
 +    b = new_buffer + b_off;                                           \
 +    begalt = new_buffer + begalt_off;                                 \
 +    if (fixup_alt_jump_set) fixup_alt_jump = new_buffer + fixup_alt_jump_off; \
 +    if (laststart_set) laststart = new_buffer + laststart_off;                \
 +    if (pending_exact_set) pending_exact = new_buffer + pending_exact_off; \
 +  } while (false)
 +
 +
 +/* Since we have one byte reserved for the register number argument to
 +   {start,stop}_memory, the maximum number of groups we can report
 +   things about is what fits in that byte.  */
 +#define MAX_REGNUM 255
 +
 +/* But patterns can have more than 'MAX_REGNUM' registers.  Just
 +   ignore the excess.  */
 +typedef int regnum_t;
 +
 +
 +/* Macros for the compile stack.  */
 +
 +/* Since offsets can go either forwards or backwards, this type needs to
 +   be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.  */
 +typedef long pattern_offset_t;
 +
 +typedef struct
 +{
 +  pattern_offset_t begalt_offset;
 +  pattern_offset_t fixup_alt_jump;
 +  pattern_offset_t laststart_offset;
 +  regnum_t regnum;
 +} compile_stack_elt_t;
 +
 +
 +typedef struct
 +{
 +  compile_stack_elt_t *stack;
 +  size_t size;
 +  size_t avail;                       /* Offset of next open position.  */
 +} compile_stack_type;
 +
 +
 +#define INIT_COMPILE_STACK_SIZE 32
 +
 +#define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)
 +#define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)
 +
 +/* The next available element.  */
 +#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
 +\f
 +/* Structure to manage work area for range table.  */
 +struct range_table_work_area
 +{
 +  int *table;                 /* actual work area.  */
 +  int allocated;              /* allocated size for work area in bytes.  */
 +  int used;                   /* actually used size in words.  */
 +  int bits;                   /* flag to record character classes */
 +};
 +
 +/* Make sure that WORK_AREA can hold more N multibyte characters.
 +   This is used only in set_image_of_range and set_image_of_range_1.
 +   It expects WORK_AREA to be a pointer.
 +   If it can't get the space, it returns from the surrounding function.  */
 +
 +#define EXTEND_RANGE_TABLE(work_area, n)                              \
 +  do {                                                                        \
 +    if (((work_area).used + (n)) * sizeof (int) > (work_area).allocated) \
 +      {                                                                       \
 +        extend_range_table_work_area (&work_area);                    \
 +        if ((work_area).table == 0)                                   \
 +          return (REG_ESPACE);                                                \
 +      }                                                                       \
 +  } while (false)
 +
 +#define SET_RANGE_TABLE_WORK_AREA_BIT(work_area, bit)         \
 +  (work_area).bits |= (bit)
 +
 +/* Set a range (RANGE_START, RANGE_END) to WORK_AREA.  */
 +#define SET_RANGE_TABLE_WORK_AREA(work_area, range_start, range_end)  \
 +  do {                                                                        \
 +    EXTEND_RANGE_TABLE ((work_area), 2);                              \
 +    (work_area).table[(work_area).used++] = (range_start);            \
 +    (work_area).table[(work_area).used++] = (range_end);              \
 +  } while (false)
 +
 +/* Free allocated memory for WORK_AREA.  */
 +#define FREE_RANGE_TABLE_WORK_AREA(work_area) \
 +  do {                                                \
 +    if ((work_area).table)                    \
 +      xfree ((work_area).table);                      \
 +  } while (false)
 +
 +#define CLEAR_RANGE_TABLE_WORK_USED(work_area) \
 +  ((work_area).used = 0, (work_area).bits = 0)
 +#define RANGE_TABLE_WORK_USED(work_area) ((work_area).used)
 +#define RANGE_TABLE_WORK_BITS(work_area) ((work_area).bits)
 +#define RANGE_TABLE_WORK_ELT(work_area, i) ((work_area).table[i])
 +
 +/* Bits used to implement the multibyte-part of the various character classes
 +   such as [:alnum:] in a charset's range table.  The code currently assumes
 +   that only the low 16 bits are used.  */
 +#define BIT_WORD      0x1
 +#define BIT_LOWER     0x2
 +#define BIT_PUNCT     0x4
 +#define BIT_SPACE     0x8
 +#define BIT_UPPER     0x10
 +#define BIT_MULTIBYTE 0x20
 +#define BIT_ALPHA     0x40
 +#define BIT_ALNUM     0x80
 +#define BIT_GRAPH     0x100
 +#define BIT_PRINT     0x200
 +#define BIT_BLANK       0x400
 +\f
 +
 +/* Set the bit for character C in a list.  */
 +#define SET_LIST_BIT(c) (b[((c)) / BYTEWIDTH] |= 1 << ((c) % BYTEWIDTH))
 +
 +
 +/* Store characters in the range FROM to TO in the bitmap at B (for
 +   ASCII and unibyte characters) and WORK_AREA (for multibyte
 +   characters) while translating them and paying attention to the
 +   continuity of translated characters.
 +
 +   Implementation note: It is better to implement these fairly big
 +   macros by a function, but it's not that easy because macros called
 +   in this macro assume various local variables already declared.  */
 +
 +/* Both FROM and TO are ASCII characters.  */
 +
 +#define SETUP_ASCII_RANGE(work_area, FROM, TO)                        \
 +  do {                                                                \
 +    int C0, C1;                                                       \
 +                                                              \
 +    for (C0 = (FROM); C0 <= (TO); C0++)                               \
 +      {                                                               \
 +      C1 = TRANSLATE (C0);                                    \
 +      if (! ASCII_CHAR_P (C1))                                \
 +        {                                                     \
 +          SET_RANGE_TABLE_WORK_AREA ((work_area), C1, C1);    \
 +          if ((C1 = RE_CHAR_TO_UNIBYTE (C1)) < 0)             \
 +            C1 = C0;                                          \
 +        }                                                     \
 +      SET_LIST_BIT (C1);                                      \
 +      }                                                               \
 +  } while (false)
 +
 +
 +/* Both FROM and TO are unibyte characters (0x80..0xFF).  */
 +
 +#define SETUP_UNIBYTE_RANGE(work_area, FROM, TO)                             \
 +  do {                                                                               \
 +    int C0, C1, C2, I;                                                               \
 +    int USED = RANGE_TABLE_WORK_USED (work_area);                            \
 +                                                                             \
 +    for (C0 = (FROM); C0 <= (TO); C0++)                                              \
 +      {                                                                              \
 +      C1 = RE_CHAR_TO_MULTIBYTE (C0);                                        \
 +      if (CHAR_BYTE8_P (C1))                                                 \
 +        SET_LIST_BIT (C0);                                                   \
 +      else                                                                   \
 +        {                                                                    \
 +          C2 = TRANSLATE (C1);                                               \
 +          if (C2 == C1                                                       \
 +              || (C1 = RE_CHAR_TO_UNIBYTE (C2)) < 0)                         \
 +            C1 = C0;                                                         \
 +          SET_LIST_BIT (C1);                                                 \
 +          for (I = RANGE_TABLE_WORK_USED (work_area) - 2; I >= USED; I -= 2) \
 +            {                                                                \
 +              int from = RANGE_TABLE_WORK_ELT (work_area, I);                \
 +              int to = RANGE_TABLE_WORK_ELT (work_area, I + 1);              \
 +                                                                             \
 +              if (C2 >= from - 1 && C2 <= to + 1)                            \
 +                {                                                            \
 +                  if (C2 == from - 1)                                        \
 +                    RANGE_TABLE_WORK_ELT (work_area, I)--;                   \
 +                  else if (C2 == to + 1)                                     \
 +                    RANGE_TABLE_WORK_ELT (work_area, I + 1)++;               \
 +                  break;                                                     \
 +                }                                                            \
 +            }                                                                \
 +          if (I < USED)                                                      \
 +            SET_RANGE_TABLE_WORK_AREA ((work_area), C2, C2);                 \
 +        }                                                                    \
 +      }                                                                              \
 +  } while (false)
 +
 +
 +/* Both FROM and TO are multibyte characters.  */
 +
 +#define SETUP_MULTIBYTE_RANGE(work_area, FROM, TO)                       \
 +  do {                                                                           \
 +    int C0, C1, C2, I, USED = RANGE_TABLE_WORK_USED (work_area);         \
 +                                                                         \
 +    SET_RANGE_TABLE_WORK_AREA ((work_area), (FROM), (TO));               \
 +    for (C0 = (FROM); C0 <= (TO); C0++)                                          \
 +      {                                                                          \
 +      C1 = TRANSLATE (C0);                                               \
 +      if ((C2 = RE_CHAR_TO_UNIBYTE (C1)) >= 0                            \
 +          || (C1 != C0 && (C2 = RE_CHAR_TO_UNIBYTE (C0)) >= 0))          \
 +        SET_LIST_BIT (C2);                                               \
 +      if (C1 >= (FROM) && C1 <= (TO))                                    \
 +        continue;                                                        \
 +      for (I = RANGE_TABLE_WORK_USED (work_area) - 2; I >= USED; I -= 2) \
 +        {                                                                \
 +          int from = RANGE_TABLE_WORK_ELT (work_area, I);                \
 +          int to = RANGE_TABLE_WORK_ELT (work_area, I + 1);              \
 +                                                                         \
 +          if (C1 >= from - 1 && C1 <= to + 1)                            \
 +            {                                                            \
 +              if (C1 == from - 1)                                        \
 +                RANGE_TABLE_WORK_ELT (work_area, I)--;                   \
 +              else if (C1 == to + 1)                                     \
 +                RANGE_TABLE_WORK_ELT (work_area, I + 1)++;               \
 +              break;                                                     \
 +            }                                                            \
 +        }                                                                \
 +      if (I < USED)                                                      \
 +        SET_RANGE_TABLE_WORK_AREA ((work_area), C1, C1);                 \
 +      }                                                                          \
 +  } while (false)
 +
 +/* Get the next unsigned number in the uncompiled pattern.  */
 +#define GET_INTERVAL_COUNT(num)                                       \
 +  do {                                                                        \
 +    if (p == pend)                                                    \
 +      FREE_STACK_RETURN (REG_EBRACE);                                 \
 +    else                                                              \
 +      {                                                                       \
 +      PATFETCH (c);                                                   \
 +      while ('0' <= c && c <= '9')                                    \
 +        {                                                             \
 +          if (num < 0)                                                \
 +            num = 0;                                                  \
 +          if (RE_DUP_MAX / 10 - (RE_DUP_MAX % 10 < c - '0') < num)    \
 +            FREE_STACK_RETURN (REG_ESIZEBR);                          \
 +          num = num * 10 + c - '0';                                   \
 +          if (p == pend)                                              \
 +            FREE_STACK_RETURN (REG_EBRACE);                           \
 +          PATFETCH (c);                                               \
 +        }                                                             \
 +      }                                                                       \
 +  } while (false)
 +\f
 +/* Parse a character class, i.e. string such as "[:name:]".  *strp
 +   points to the string to be parsed and limit is length, in bytes, of
 +   that string.
 +
 +   If *strp point to a string that begins with "[:name:]", where name is
 +   a non-empty sequence of lower case letters, *strp will be advanced past the
 +   closing square bracket and RECC_* constant which maps to the name will be
 +   returned.  If name is not a valid character class name zero, or RECC_ERROR,
 +   is returned.
 +
 +   Otherwise, if *strp doesn't begin with "[:name:]", -1 is returned.
 +
 +   The function can be used on ASCII and multibyte (UTF-8-encoded) strings.
 + */
 +re_wctype_t
 +re_wctype_parse (const unsigned char **strp, unsigned limit)
 +{
 +  const char *beg = (const char *)*strp, *it;
 +
 +  if (limit < 4 || beg[0] != '[' || beg[1] != ':')
 +    return -1;
 +
 +  beg += 2;  /* skip opening "[:" */
 +  limit -= 3;  /* opening "[:" and half of closing ":]"; --limit handles rest */
 +  for (it = beg; it[0] != ':' || it[1] != ']'; ++it)
 +    if (!--limit)
 +      return -1;
 +
 +  *strp = (const unsigned char *)(it + 2);
 +
 +  /* Sort tests in the length=five case by frequency the classes to minimize
 +     number of times we fail the comparison.  The frequencies of character class
 +     names used in Emacs sources as of 2016-07-27:
 +
 +     $ find \( -name \*.c -o -name \*.el \) -exec grep -h '\[:[a-z]*:]' {} + |
 +           sed 's/]/]\n/g' |grep -o '\[:[a-z]*:]' |sort |uniq -c |sort -nr
 +         213 [:alnum:]
 +         104 [:alpha:]
 +          62 [:space:]
 +          39 [:digit:]
 +          36 [:blank:]
 +          26 [:word:]
 +          26 [:upper:]
 +          21 [:lower:]
 +          10 [:xdigit:]
 +          10 [:punct:]
 +          10 [:ascii:]
 +           4 [:nonascii:]
 +           4 [:graph:]
 +           2 [:print:]
 +           2 [:cntrl:]
 +           1 [:ff:]
 +
 +     If you update this list, consider also updating chain of or'ed conditions
 +     in execute_charset function.
 +   */
 +
 +  switch (it - beg) {
 +  case 4:
 +    if (!memcmp (beg, "word", 4))      return RECC_WORD;
 +    break;
 +  case 5:
 +    if (!memcmp (beg, "alnum", 5))     return RECC_ALNUM;
 +    if (!memcmp (beg, "alpha", 5))     return RECC_ALPHA;
 +    if (!memcmp (beg, "space", 5))     return RECC_SPACE;
 +    if (!memcmp (beg, "digit", 5))     return RECC_DIGIT;
 +    if (!memcmp (beg, "blank", 5))     return RECC_BLANK;
 +    if (!memcmp (beg, "upper", 5))     return RECC_UPPER;
 +    if (!memcmp (beg, "lower", 5))     return RECC_LOWER;
 +    if (!memcmp (beg, "punct", 5))     return RECC_PUNCT;
 +    if (!memcmp (beg, "ascii", 5))     return RECC_ASCII;
 +    if (!memcmp (beg, "graph", 5))     return RECC_GRAPH;
 +    if (!memcmp (beg, "print", 5))     return RECC_PRINT;
 +    if (!memcmp (beg, "cntrl", 5))     return RECC_CNTRL;
 +    break;
 +  case 6:
 +    if (!memcmp (beg, "xdigit", 6))    return RECC_XDIGIT;
 +    break;
 +  case 7:
 +    if (!memcmp (beg, "unibyte", 7))   return RECC_UNIBYTE;
 +    break;
 +  case 8:
 +    if (!memcmp (beg, "nonascii", 8))  return RECC_NONASCII;
 +    break;
 +  case 9:
 +    if (!memcmp (beg, "multibyte", 9)) return RECC_MULTIBYTE;
 +    break;
 +  }
 +
 +  return RECC_ERROR;
 +}
 +
 +/* True if CH is in the char class CC.  */
 +bool
 +re_iswctype (int ch, re_wctype_t cc)
 +{
 +  switch (cc)
 +    {
 +    case RECC_ALNUM: return ISALNUM (ch) != 0;
 +    case RECC_ALPHA: return ISALPHA (ch) != 0;
 +    case RECC_BLANK: return ISBLANK (ch) != 0;
 +    case RECC_CNTRL: return ISCNTRL (ch) != 0;
 +    case RECC_DIGIT: return ISDIGIT (ch) != 0;
 +    case RECC_GRAPH: return ISGRAPH (ch) != 0;
 +    case RECC_LOWER: return ISLOWER (ch) != 0;
 +    case RECC_PRINT: return ISPRINT (ch) != 0;
 +    case RECC_PUNCT: return ISPUNCT (ch) != 0;
 +    case RECC_SPACE: return ISSPACE (ch) != 0;
 +    case RECC_UPPER: return ISUPPER (ch) != 0;
 +    case RECC_XDIGIT: return ISXDIGIT (ch) != 0;
 +    case RECC_ASCII: return IS_REAL_ASCII (ch) != 0;
 +    case RECC_NONASCII: return !IS_REAL_ASCII (ch);
 +    case RECC_UNIBYTE: return ISUNIBYTE (ch) != 0;
 +    case RECC_MULTIBYTE: return !ISUNIBYTE (ch);
 +    case RECC_WORD: return ISWORD (ch) != 0;
 +    case RECC_ERROR: return false;
 +    default:
 +      abort ();
 +    }
 +}
 +
 +/* Return a bit-pattern to use in the range-table bits to match multibyte
 +   chars of class CC.  */
 +static int
 +re_wctype_to_bit (re_wctype_t cc)
 +{
 +  switch (cc)
 +    {
 +    case RECC_NONASCII:
 +    case RECC_MULTIBYTE: return BIT_MULTIBYTE;
 +    case RECC_ALPHA: return BIT_ALPHA;
 +    case RECC_ALNUM: return BIT_ALNUM;
 +    case RECC_WORD: return BIT_WORD;
 +    case RECC_LOWER: return BIT_LOWER;
 +    case RECC_UPPER: return BIT_UPPER;
 +    case RECC_PUNCT: return BIT_PUNCT;
 +    case RECC_SPACE: return BIT_SPACE;
 +    case RECC_GRAPH: return BIT_GRAPH;
 +    case RECC_PRINT: return BIT_PRINT;
 +    case RECC_BLANK: return BIT_BLANK;
 +    case RECC_ASCII: case RECC_DIGIT: case RECC_XDIGIT: case RECC_CNTRL:
 +    case RECC_UNIBYTE: case RECC_ERROR: return 0;
 +    default:
 +      abort ();
 +    }
 +}
 +\f
 +/* Filling in the work area of a range.  */
 +
 +/* Actually extend the space in WORK_AREA.  */
 +
 +static void
 +extend_range_table_work_area (struct range_table_work_area *work_area)
 +{
 +  work_area->allocated += 16 * sizeof (int);
 +  work_area->table = xrealloc (work_area->table, work_area->allocated);
 +}
 +\f
 +/* regex_compile and helpers.  */
 +
 +static bool group_in_compile_stack (compile_stack_type, regnum_t);
 +
 +/* Insert the 'jump' from the end of last alternative to "here".
 +   The space for the jump has already been allocated. */
 +#define FIXUP_ALT_JUMP()                                              \
 +do {                                                                  \
 +  if (fixup_alt_jump)                                                 \
 +    STORE_JUMP (jump, fixup_alt_jump, b);                             \
 +} while (false)
 +
 +
 +/* Return, freeing storage we allocated.  */
 +#define FREE_STACK_RETURN(value)              \
 +  do {                                                        \
 +    FREE_RANGE_TABLE_WORK_AREA (range_table_work);    \
 +    xfree (compile_stack.stack);                      \
 +    return value;                                     \
 +  } while (false)
 +
 +/* Compile PATTERN (of length SIZE) according to SYNTAX.
 +   Return a nonzero error code on failure, or zero for success.
 +
 +   If WHITESPACE_REGEXP is given, use it instead of a space
 +   character in PATTERN.
 +
 +   Assume the 'allocated' (and perhaps 'buffer') and 'translate'
 +   fields are set in BUFP on entry.
 +
 +   If successful, put results in *BUFP (otherwise the
 +   contents of *BUFP are undefined):
 +     'buffer' is the compiled pattern;
 +     'syntax' is set to SYNTAX;
 +     'used' is set to the length of the compiled pattern;
 +     'fastmap_accurate' is zero;
 +     're_nsub' is the number of subexpressions in PATTERN;
 +
 +   The 'fastmap' field is neither examined nor set.  */
 +
 +static reg_errcode_t
 +regex_compile (re_char *pattern, size_t size,
 +             bool posix_backtracking,
 +             const char *whitespace_regexp,
 +             struct re_pattern_buffer *bufp)
 +{
 +  /* Fetch characters from PATTERN here.  */
 +  int c, c1;
 +
 +  /* Points to the end of the buffer, where we should append.  */
 +  unsigned char *b;
 +
 +  /* Keeps track of unclosed groups.  */
 +  compile_stack_type compile_stack;
 +
 +  /* Points to the current (ending) position in the pattern.  */
 +  re_char *p = pattern;
 +  re_char *pend = pattern + size;
 +
 +  /* How to translate the characters in the pattern.  */
 +  Lisp_Object translate = bufp->translate;
 +
 +  /* Address of the count-byte of the most recently inserted 'exactn'
 +     command.  This makes it possible to tell if a new exact-match
 +     character can be added to that command or if the character requires
 +     a new 'exactn' command.  */
 +  unsigned char *pending_exact = 0;
 +
 +  /* Address of start of the most recently finished expression.
 +     This tells, e.g., postfix * where to find the start of its
 +     operand.  Reset at the beginning of groups and alternatives.  */
 +  unsigned char *laststart = 0;
 +
 +  /* Address of beginning of regexp, or inside of last group.  */
 +  unsigned char *begalt;
 +
 +  /* Place in the uncompiled pattern (i.e., the {) to
 +     which to go back if the interval is invalid.  */
 +  re_char *beg_interval;
 +
 +  /* Address of the place where a forward jump should go to the end of
 +     the containing expression.  Each alternative of an 'or' -- except the
 +     last -- ends with a forward jump of this sort.  */
 +  unsigned char *fixup_alt_jump = 0;
 +
 +  /* Work area for range table of charset.  */
 +  struct range_table_work_area range_table_work;
 +
 +  /* If the object matched can contain multibyte characters.  */
 +  bool multibyte = RE_MULTIBYTE_P (bufp);
 +
 +  /* Nonzero if we have pushed down into a subpattern.  */
 +  int in_subpattern = 0;
 +
 +  /* These hold the values of p, pattern, and pend from the main
 +     pattern when we have pushed into a subpattern.  */
 +  re_char *main_p;
 +  re_char *main_pattern;
 +  re_char *main_pend;
 +
 +#ifdef REGEX_EMACS_DEBUG
 +  regex_emacs_debug++;
 +  DEBUG_PRINT ("\nCompiling pattern: ");
 +  if (regex_emacs_debug > 0)
 +    {
 +      size_t debug_count;
 +
 +      for (debug_count = 0; debug_count < size; debug_count++)
 +      putchar (pattern[debug_count]);
 +      putchar ('\n');
 +    }
 +#endif
 +
 +  /* Initialize the compile stack.  */
 +  compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
 +  compile_stack.size = INIT_COMPILE_STACK_SIZE;
 +  compile_stack.avail = 0;
 +
 +  range_table_work.table = 0;
 +  range_table_work.allocated = 0;
 +
 +  /* Initialize the pattern buffer.  */
 +  bufp->fastmap_accurate = 0;
 +  bufp->used_syntax = 0;
 +
 +  /* Set 'used' to zero, so that if we return an error, the pattern
 +     printer (for debugging) will think there's no pattern.  We reset it
 +     at the end.  */
 +  bufp->used = 0;
 +
 +  bufp->re_nsub = 0;
 +
 +  if (bufp->allocated == 0)
 +    {
 +      if (bufp->buffer)
 +      { /* If zero allocated, but buffer is non-null, try to realloc
 +           enough space.  This loses if buffer's address is bogus, but
 +           that is the user's responsibility.  */
 +        RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char);
 +      }
 +      else
 +      { /* Caller did not allocate a buffer.  Do it for them.  */
 +        bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char);
 +      }
 +      bufp->allocated = INIT_BUF_SIZE;
 +    }
 +
 +  begalt = b = bufp->buffer;
 +
 +  /* Loop through the uncompiled pattern until we're at the end.  */
 +  while (1)
 +    {
 +      if (p == pend)
 +      {
 +        /* If this is the end of an included regexp,
 +           pop back to the main regexp and try again.  */
 +        if (in_subpattern)
 +          {
 +            in_subpattern = 0;
 +            pattern = main_pattern;
 +            p = main_p;
 +            pend = main_pend;
 +            continue;
 +          }
 +        /* If this is the end of the main regexp, we are done.  */
 +        break;
 +      }
 +
 +      PATFETCH (c);
 +
 +      switch (c)
 +      {
 +      case ' ':
 +        {
 +          re_char *p1 = p;
 +
 +          /* If there's no special whitespace regexp, treat
 +             spaces normally.  And don't try to do this recursively.  */
 +          if (!whitespace_regexp || in_subpattern)
 +            goto normal_char;
 +
 +          /* Peek past following spaces.  */
 +          while (p1 != pend)
 +            {
 +              if (*p1 != ' ')
 +                break;
 +              p1++;
 +            }
 +          /* If the spaces are followed by a repetition op,
 +             treat them normally.  */
 +          if (p1 != pend
 +              && (*p1 == '*' || *p1 == '+' || *p1 == '?'
 +                  || (*p1 == '\\' && p1 + 1 != pend && p1[1] == '{')))
 +            goto normal_char;
 +
 +          /* Replace the spaces with the whitespace regexp.  */
 +          in_subpattern = 1;
 +          main_p = p1;
 +          main_pend = pend;
 +          main_pattern = pattern;
 +          p = pattern = (re_char *) whitespace_regexp;
 +          pend = p + strlen (whitespace_regexp);
 +          break;
 +        }
 +
 +      case '^':
 +        if (! (p == pattern + 1 || at_begline_loc_p (pattern, p)))
 +          goto normal_char;
 +        BUF_PUSH (begline);
 +        break;
 +
 +      case '$':
 +        if (! (p == pend || at_endline_loc_p (p, pend)))
 +          goto normal_char;
 +        BUF_PUSH (endline);
 +        break;
 +
 +
 +      case '+':
 +      case '?':
 +      case '*':
 +        /* If there is no previous pattern...  */
 +        if (!laststart)
 +          goto normal_char;
 +
 +        {
 +          /* 1 means zero (many) matches is allowed.  */
 +          bool zero_times_ok = false, many_times_ok = false;
 +          bool greedy = true;
 +
 +          /* If there is a sequence of repetition chars, collapse it
 +             down to just one (the right one).  We can't combine
 +             interval operators with these because of, e.g., 'a{2}*',
 +             which should only match an even number of 'a's.  */
 +
 +          for (;;)
 +            {
 +              if (c == '?' && (zero_times_ok || many_times_ok))
 +                greedy = false;
 +              else
 +                {
 +                  zero_times_ok |= c != '+';
 +                  many_times_ok |= c != '?';
 +                }
 +
 +              if (! (p < pend && (*p == '*' || *p == '+' || *p == '?')))
 +                break;
 +              /* If we get here, we found another repeat character.  */
 +              c = *p++;
 +             }
 +
 +          /* Star, etc. applied to an empty pattern is equivalent
 +             to an empty pattern.  */
 +          if (!laststart || laststart == b)
 +            break;
 +
 +          /* Now we know whether or not zero matches is allowed
 +             and also whether or not two or more matches is allowed.  */
 +          if (greedy)
 +            {
 +              if (many_times_ok)
 +                {
 +                  bool simple = skip_one_char (laststart) == b;
 +                  size_t startoffset = 0;
 +                  re_opcode_t ofj =
 +                    /* Check if the loop can match the empty string.  */
 +                    (simple || !analyze_first (laststart, b, NULL, 0))
 +                    ? on_failure_jump : on_failure_jump_loop;
 +                  eassert (skip_one_char (laststart) <= b);
 +
 +                  if (!zero_times_ok && simple)
 +                    { /* Since simple * loops can be made faster by using
 +                         on_failure_keep_string_jump, we turn simple P+
 +                         into PP* if P is simple.  */
 +                      unsigned char *p1, *p2;
 +                      startoffset = b - laststart;
 +                      GET_BUFFER_SPACE (startoffset);
 +                      p1 = b; p2 = laststart;
 +                      while (p2 < p1)
 +                        *b++ = *p2++;
 +                      zero_times_ok = 1;
 +                    }
 +
 +                  GET_BUFFER_SPACE (6);
 +                  if (!zero_times_ok)
 +                    /* A + loop.  */
 +                    STORE_JUMP (ofj, b, b + 6);
 +                  else
 +                    /* Simple * loops can use on_failure_keep_string_jump
 +                       depending on what follows.  But since we don't know
 +                       that yet, we leave the decision up to
 +                       on_failure_jump_smart.  */
 +                    INSERT_JUMP (simple ? on_failure_jump_smart : ofj,
 +                                 laststart + startoffset, b + 6);
 +                  b += 3;
 +                  STORE_JUMP (jump, b, laststart + startoffset);
 +                  b += 3;
 +                }
 +              else
 +                {
 +                  /* A simple ? pattern.  */
 +                  eassert (zero_times_ok);
 +                  GET_BUFFER_SPACE (3);
 +                  INSERT_JUMP (on_failure_jump, laststart, b + 3);
 +                  b += 3;
 +                }
 +            }
 +          else                /* not greedy */
 +            { /* I wish the greedy and non-greedy cases could be merged.  */
 +
 +              GET_BUFFER_SPACE (7); /* We might use less.  */
 +              if (many_times_ok)
 +                {
 +                  bool emptyp = analyze_first (laststart, b, NULL, 0);
 +
 +                  /* The non-greedy multiple match looks like
 +                     a repeat..until: we only need a conditional jump
 +                     at the end of the loop.  */
 +                  if (emptyp) BUF_PUSH (no_op);
 +                  STORE_JUMP (emptyp ? on_failure_jump_nastyloop
 +                              : on_failure_jump, b, laststart);
 +                  b += 3;
 +                  if (zero_times_ok)
 +                    {
 +                      /* The repeat...until naturally matches one or more.
 +                         To also match zero times, we need to first jump to
 +                         the end of the loop (its conditional jump).  */
 +                      INSERT_JUMP (jump, laststart, b);
 +                      b += 3;
 +                    }
 +                }
 +              else
 +                {
 +                  /* non-greedy a?? */
 +                  INSERT_JUMP (jump, laststart, b + 3);
 +                  b += 3;
 +                  INSERT_JUMP (on_failure_jump, laststart, laststart + 6);
 +                  b += 3;
 +                }
 +            }
 +        }
 +        pending_exact = 0;
 +        break;
 +
 +
 +      case '.':
 +        laststart = b;
 +        BUF_PUSH (anychar);
 +        break;
 +
 +
 +      case '[':
 +        {
 +          re_char *p1;
 +
 +          CLEAR_RANGE_TABLE_WORK_USED (range_table_work);
 +
 +          if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
 +
 +          /* Ensure that we have enough space to push a charset: the
 +             opcode, the length count, and the bitset; 34 bytes in all.  */
 +          GET_BUFFER_SPACE (34);
 +
 +          laststart = b;
 +
 +          /* Test '*p == '^' twice, instead of using an if
 +             statement, so we need only one BUF_PUSH.  */
 +          BUF_PUSH (*p == '^' ? charset_not : charset);
 +          if (*p == '^')
 +            p++;
 +
 +          /* Remember the first position in the bracket expression.  */
 +          p1 = p;
 +
 +          /* Push the number of bytes in the bitmap.  */
 +          BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
 +
 +          /* Clear the whole map.  */
 +          memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
 +
 +          /* Read in characters and ranges, setting map bits.  */
 +          for (;;)
 +            {
 +              const unsigned char *p2 = p;
 +              int ch;
 +
 +              if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
 +
 +              /* See if we're at the beginning of a possible character
 +                 class.  */
 +              re_wctype_t cc = re_wctype_parse (&p, pend - p);
 +              if (cc != -1)
 +                {
 +                  if (cc == 0)
 +                    FREE_STACK_RETURN (REG_ECTYPE);
 +
 +                  if (p == pend)
 +                    FREE_STACK_RETURN (REG_EBRACK);
 +
 +                  /* Most character classes in a multibyte match just set
 +                     a flag.  Exceptions are is_blank, is_digit, is_cntrl, and
 +                     is_xdigit, since they can only match ASCII characters.
 +                     We don't need to handle them for multibyte.  */
 +
 +                  /* Setup the gl_state object to its buffer-defined value.
 +                     This hardcodes the buffer-global syntax-table for ASCII
 +                     chars, while the other chars will obey syntax-table
 +                     properties.  It's not ideal, but it's the way it's been
 +                     done until now.  */
 +                  SETUP_BUFFER_SYNTAX_TABLE ();
 +
 +                  for (c = 0; c < 0x80; ++c)
 +                    if (re_iswctype (c, cc))
 +                      {
 +                        SET_LIST_BIT (c);
 +                        c1 = TRANSLATE (c);
 +                        if (c1 == c)
 +                          continue;
 +                        if (ASCII_CHAR_P (c1))
 +                          SET_LIST_BIT (c1);
 +                        else if ((c1 = RE_CHAR_TO_UNIBYTE (c1)) >= 0)
 +                          SET_LIST_BIT (c1);
 +                      }
 +                  SET_RANGE_TABLE_WORK_AREA_BIT
 +                    (range_table_work, re_wctype_to_bit (cc));
 +
 +                  /* In most cases the matching rule for char classes only
 +                     uses the syntax table for multibyte chars, so that the
 +                     content of the syntax-table is not hardcoded in the
 +                     range_table.  SPACE and WORD are the two exceptions.  */
 +                  if ((1 << cc) & ((1 << RECC_SPACE) | (1 << RECC_WORD)))
 +                    bufp->used_syntax = 1;
 +
 +                  /* Repeat the loop. */
 +                  continue;
 +                }
 +
 +              /* Don't translate yet.  The range TRANSLATE(X..Y) cannot
 +                 always be determined from TRANSLATE(X) and TRANSLATE(Y)
 +                 So the translation is done later in a loop.  Example:
 +                 (let ((case-fold-search t)) (string-match "[A-_]" "A"))  */
 +              PATFETCH (c);
 +
 +              /* Could be the end of the bracket expression.  If it's
 +                 not (i.e., when the bracket expression is '[]' so
 +                 far), the ']' character bit gets set way below.  */
 +              if (c == ']' && p2 != p1)
 +                break;
 +
 +              if (p < pend && p[0] == '-' && p[1] != ']')
 +                {
 +
 +                  /* Discard the '-'. */
 +                  PATFETCH (c1);
 +
 +                  /* Fetch the character which ends the range. */
 +                  PATFETCH (c1);
 +
 +                  if (CHAR_BYTE8_P (c1)
 +                      && ! ASCII_CHAR_P (c) && ! CHAR_BYTE8_P (c))
 +                    /* Treat the range from a multibyte character to
 +                       raw-byte character as empty.  */
 +                    c = c1 + 1;
 +                }
 +              else
 +                /* Range from C to C. */
 +                c1 = c;
 +
 +              if (c <= c1)
 +                {
 +                  if (c < 128)
 +                    {
 +                      ch = min (127, c1);
 +                      SETUP_ASCII_RANGE (range_table_work, c, ch);
 +                      c = ch + 1;
 +                      if (CHAR_BYTE8_P (c1))
 +                        c = BYTE8_TO_CHAR (128);
 +                    }
 +                  if (CHAR_BYTE8_P (c))
 +                    {
 +                      c = CHAR_TO_BYTE8 (c);
 +                      c1 = CHAR_TO_BYTE8 (c1);
 +                      for (; c <= c1; c++)
 +                        SET_LIST_BIT (c);
 +                    }
 +                  else if (multibyte)
 +                    SETUP_MULTIBYTE_RANGE (range_table_work, c, c1);
 +                  else
 +                    SETUP_UNIBYTE_RANGE (range_table_work, c, c1);
 +                }
 +            }
 +
 +          /* Discard any (non)matching list bytes that are all 0 at the
 +             end of the map.  Decrease the map-length byte too.  */
 +          while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
 +            b[-1]--;
 +          b += b[-1];
 +
 +          /* Build real range table from work area.  */
 +          if (RANGE_TABLE_WORK_USED (range_table_work)
 +              || RANGE_TABLE_WORK_BITS (range_table_work))
 +            {
 +              int i;
 +              int used = RANGE_TABLE_WORK_USED (range_table_work);
 +
 +              /* Allocate space for COUNT + RANGE_TABLE.  Needs two
 +                 bytes for flags, two for COUNT, and three bytes for
 +                 each character.  */
 +              GET_BUFFER_SPACE (4 + used * 3);
 +
 +              /* Indicate the existence of range table.  */
 +              laststart[1] |= 0x80;
 +
 +              /* Store the character class flag bits into the range table.  */
 +              *b++ = RANGE_TABLE_WORK_BITS (range_table_work) & 0xff;
 +              *b++ = RANGE_TABLE_WORK_BITS (range_table_work) >> 8;
 +
 +              STORE_NUMBER_AND_INCR (b, used / 2);
 +              for (i = 0; i < used; i++)
 +                STORE_CHARACTER_AND_INCR
 +                  (b, RANGE_TABLE_WORK_ELT (range_table_work, i));
 +            }
 +        }
 +        break;
 +
 +
 +      case '\\':
 +        if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
 +
 +        /* Do not translate the character after the \, so that we can
 +           distinguish, e.g., \B from \b, even if we normally would
 +           translate, e.g., B to b.  */
 +        PATFETCH (c);
 +
 +        switch (c)
 +          {
 +          case '(':
 +            {
 +              int shy = 0;
 +              regnum_t regnum = 0;
 +              if (p+1 < pend)
 +                {
 +                  /* Look for a special (?...) construct */
 +                  if (*p == '?')
 +                    {
 +                      PATFETCH (c); /* Gobble up the '?'.  */
 +                      while (!shy)
 +                        {
 +                          PATFETCH (c);
 +                          switch (c)
 +                            {
 +                            case ':': shy = 1; break;
 +                            case '0':
 +                              /* An explicitly specified regnum must start
 +                                 with non-0. */
 +                              if (regnum == 0)
 +                                FREE_STACK_RETURN (REG_BADPAT);
 +                              FALLTHROUGH;
 +                            case '1': case '2': case '3': case '4':
 +                            case '5': case '6': case '7': case '8': case '9':
 +                              regnum = 10*regnum + (c - '0'); break;
 +                            default:
 +                              /* Only (?:...) is supported right now. */
 +                              FREE_STACK_RETURN (REG_BADPAT);
 +                            }
 +                        }
 +                    }
 +                }
 +
 +              if (!shy)
 +                regnum = ++bufp->re_nsub;
 +              else if (regnum)
 +                { /* It's actually not shy, but explicitly numbered.  */
 +                  shy = 0;
 +                  if (regnum > bufp->re_nsub)
 +                    bufp->re_nsub = regnum;
 +                  else if (regnum > bufp->re_nsub
 +                           /* Ideally, we'd want to check that the specified
 +                              group can't have matched (i.e. all subgroups
 +                              using the same regnum are in other branches of
 +                              OR patterns), but we don't currently keep track
 +                              of enough info to do that easily.  */
 +                           || group_in_compile_stack (compile_stack, regnum))
 +                    FREE_STACK_RETURN (REG_BADPAT);
 +                }
 +              else
 +                /* It's really shy.  */
 +                regnum = - bufp->re_nsub;
 +
 +              if (COMPILE_STACK_FULL)
 +                {
 +                  RETALLOC (compile_stack.stack, compile_stack.size << 1,
 +                            compile_stack_elt_t);
 +                  compile_stack.size <<= 1;
 +                }
 +
 +              /* These are the values to restore when we hit end of this
 +                 group.  They are all relative offsets, so that if the
 +                 whole pattern moves because of realloc, they will still
 +                 be valid.  */
 +              COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;
 +              COMPILE_STACK_TOP.fixup_alt_jump
 +                = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
 +              COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;
 +              COMPILE_STACK_TOP.regnum = regnum;
 +
 +              /* Do not push a start_memory for groups beyond the last one
 +                 we can represent in the compiled pattern.  */
 +              if (regnum <= MAX_REGNUM && regnum > 0)
 +                BUF_PUSH_2 (start_memory, regnum);
 +
 +              compile_stack.avail++;
 +
 +              fixup_alt_jump = 0;
 +              laststart = 0;
 +              begalt = b;
 +              /* If we've reached MAX_REGNUM groups, then this open
 +                 won't actually generate any code, so we'll have to
 +                 clear pending_exact explicitly.  */
 +              pending_exact = 0;
 +              break;
 +            }
 +
 +          case ')':
 +            if (COMPILE_STACK_EMPTY)
 +              FREE_STACK_RETURN (REG_ERPAREN);
 +
 +            FIXUP_ALT_JUMP ();
 +
 +            /* See similar code for backslashed left paren above.  */
 +            if (COMPILE_STACK_EMPTY)
 +              FREE_STACK_RETURN (REG_ERPAREN);
 +
 +            /* Since we just checked for an empty stack above, this
 +               "can't happen".  */
 +            eassert (compile_stack.avail != 0);
 +            {
 +              /* We don't just want to restore into 'regnum', because
 +                 later groups should continue to be numbered higher,
 +                 as in '(ab)c(de)' -- the second group is #2.  */
 +              regnum_t regnum;
 +
 +              compile_stack.avail--;
 +              begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;
 +              fixup_alt_jump
 +                = COMPILE_STACK_TOP.fixup_alt_jump
 +                  ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1
 +                  : 0;
 +              laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;
 +              regnum = COMPILE_STACK_TOP.regnum;
 +              /* If we've reached MAX_REGNUM groups, then this open
 +                 won't actually generate any code, so we'll have to
 +                 clear pending_exact explicitly.  */
 +              pending_exact = 0;
 +
 +              /* We're at the end of the group, so now we know how many
 +                 groups were inside this one.  */
 +              if (regnum <= MAX_REGNUM && regnum > 0)
 +                BUF_PUSH_2 (stop_memory, regnum);
 +            }
 +            break;
 +
 +
 +          case '|':                                   /* '\|'.  */
 +            /* Insert before the previous alternative a jump which
 +               jumps to this alternative if the former fails.  */
 +            GET_BUFFER_SPACE (3);
 +            INSERT_JUMP (on_failure_jump, begalt, b + 6);
 +            pending_exact = 0;
 +            b += 3;
 +
 +            /* The alternative before this one has a jump after it
 +               which gets executed if it gets matched.  Adjust that
 +               jump so it will jump to this alternative's analogous
 +               jump (put in below, which in turn will jump to the next
 +               (if any) alternative's such jump, etc.).  The last such
 +               jump jumps to the correct final destination.  A picture:
 +                        _____ _____
 +                        |   | |   |
 +                        |   v |   v
 +                      A | B   | C
 +
 +               If we are at B, then fixup_alt_jump right now points to a
 +               three-byte space after A.  We'll put in the jump, set
 +               fixup_alt_jump to right after B, and leave behind three
 +               bytes which we'll fill in when we get to after C.  */
 +
 +            FIXUP_ALT_JUMP ();
 +
 +            /* Mark and leave space for a jump after this alternative,
 +               to be filled in later either by next alternative or
 +               when know we're at the end of a series of alternatives.  */
 +            fixup_alt_jump = b;
 +            GET_BUFFER_SPACE (3);
 +            b += 3;
 +
 +            laststart = 0;
 +            begalt = b;
 +            break;
 +
 +
 +          case '{':
 +            {
 +              /* At least (most) this many matches must be made.  */
 +              int lower_bound = 0, upper_bound = -1;
 +
 +              beg_interval = p;
 +
 +              GET_INTERVAL_COUNT (lower_bound);
 +
 +              if (c == ',')
 +                GET_INTERVAL_COUNT (upper_bound);
 +              else
 +                /* Interval such as '{1}' => match exactly once. */
 +                upper_bound = lower_bound;
 +
 +              if (lower_bound < 0
 +                  || (0 <= upper_bound && upper_bound < lower_bound)
 +                  || c != '\\')
 +                FREE_STACK_RETURN (REG_BADBR);
 +              if (p == pend)
 +                FREE_STACK_RETURN (REG_EESCAPE);
 +              if (*p++ != '}')
 +                FREE_STACK_RETURN (REG_BADBR);
 +
 +              /* We just parsed a valid interval.  */
 +
 +              /* If it's invalid to have no preceding re.  */
 +              if (!laststart)
 +                goto unfetch_interval;
 +
 +              if (upper_bound == 0)
 +                /* If the upper bound is zero, just drop the sub pattern
 +                   altogether.  */
 +                b = laststart;
 +              else if (lower_bound == 1 && upper_bound == 1)
 +                /* Just match it once: nothing to do here.  */
 +                ;
 +
 +              /* Otherwise, we have a nontrivial interval.  When
 +                 we're all done, the pattern will look like:
 +                 set_number_at <jump count> <upper bound>
 +                 set_number_at <succeed_n count> <lower bound>
 +                 succeed_n <after jump addr> <succeed_n count>
 +                 <body of loop>
 +                 jump_n <succeed_n addr> <jump count>
 +                 (The upper bound and 'jump_n' are omitted if
 +                 'upper_bound' is 1, though.)  */
 +              else
 +                { /* If the upper bound is > 1, we need to insert
 +                     more at the end of the loop.  */
 +                  unsigned int nbytes = (upper_bound < 0 ? 3
 +                                         : upper_bound > 1 ? 5 : 0);
 +                  unsigned int startoffset = 0;
 +
 +                  GET_BUFFER_SPACE (20); /* We might use less.  */
 +
 +                  if (lower_bound == 0)
 +                    {
 +                      /* A succeed_n that starts with 0 is really a
 +                         a simple on_failure_jump_loop.  */
 +                      INSERT_JUMP (on_failure_jump_loop, laststart,
 +                                   b + 3 + nbytes);
 +                      b += 3;
 +                    }
 +                  else
 +                    {
 +                      /* Initialize lower bound of the 'succeed_n', even
 +                         though it will be set during matching by its
 +                         attendant 'set_number_at' (inserted next),
 +                         because 're_compile_fastmap' needs to know.
 +                         Jump to the 'jump_n' we might insert below.  */
 +                      INSERT_JUMP2 (succeed_n, laststart,
 +                                    b + 5 + nbytes,
 +                                    lower_bound);
 +                      b += 5;
 +
 +                      /* Code to initialize the lower bound.  Insert
 +                         before the 'succeed_n'.  The '5' is the last two
 +                         bytes of this 'set_number_at', plus 3 bytes of
 +                         the following 'succeed_n'.  */
 +                      insert_op2 (set_number_at, laststart, 5,
 +                                  lower_bound, b);
 +                      b += 5;
 +                      startoffset += 5;
 +                    }
 +
 +                  if (upper_bound < 0)
 +                    {
 +                      /* A negative upper bound stands for infinity,
 +                         in which case it degenerates to a plain jump.  */
 +                      STORE_JUMP (jump, b, laststart + startoffset);
 +                      b += 3;
 +                    }
 +                  else if (upper_bound > 1)
 +                    { /* More than one repetition is allowed, so
 +                         append a backward jump to the 'succeed_n'
 +                         that starts this interval.
 +
 +                         When we've reached this during matching,
 +                         we'll have matched the interval once, so
 +                         jump back only 'upper_bound - 1' times.  */
 +                      STORE_JUMP2 (jump_n, b, laststart + startoffset,
 +                                   upper_bound - 1);
 +                      b += 5;
 +
 +                      /* The location we want to set is the second
 +                         parameter of the 'jump_n'; that is 'b-2' as
 +                         an absolute address.  'laststart' will be
 +                         the 'set_number_at' we're about to insert;
 +                         'laststart+3' the number to set, the source
 +                         for the relative address.  But we are
 +                         inserting into the middle of the pattern --
 +                         so everything is getting moved up by 5.
 +                         Conclusion: (b - 2) - (laststart + 3) + 5,
 +                         i.e., b - laststart.
 +
 +                         Insert this at the beginning of the loop
 +                         so that if we fail during matching, we'll
 +                         reinitialize the bounds.  */
 +                      insert_op2 (set_number_at, laststart, b - laststart,
 +                                  upper_bound - 1, b);
 +                      b += 5;
 +                    }
 +                }
 +              pending_exact = 0;
 +              beg_interval = NULL;
 +            }
 +            break;
 +
 +          unfetch_interval:
 +            /* If an invalid interval, match the characters as literals.  */
 +             eassert (beg_interval);
 +             p = beg_interval;
 +             beg_interval = NULL;
 +             eassert (p > pattern && p[-1] == '\\');
 +             c = '{';
 +             goto normal_char;
 +
 +          case '=':
 +            laststart = b;
 +            BUF_PUSH (at_dot);
 +            break;
 +
 +          case 's':
 +            laststart = b;
 +            PATFETCH (c);
 +            BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
 +            break;
 +
 +          case 'S':
 +            laststart = b;
 +            PATFETCH (c);
 +            BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);
 +            break;
 +
 +          case 'c':
 +            laststart = b;
 +            PATFETCH (c);
 +            BUF_PUSH_2 (categoryspec, c);
 +            break;
 +
 +          case 'C':
 +            laststart = b;
 +            PATFETCH (c);
 +            BUF_PUSH_2 (notcategoryspec, c);
 +            break;
 +
 +          case 'w':
 +            laststart = b;
 +            BUF_PUSH_2 (syntaxspec, Sword);
 +            break;
 +
 +
 +          case 'W':
 +            laststart = b;
 +            BUF_PUSH_2 (notsyntaxspec, Sword);
 +            break;
 +
 +
 +          case '<':
 +            laststart = b;
 +            BUF_PUSH (wordbeg);
 +            break;
 +
 +          case '>':
 +            laststart = b;
 +            BUF_PUSH (wordend);
 +            break;
 +
 +          case '_':
 +              laststart = b;
 +              PATFETCH (c);
 +              if (c == '<')
 +                BUF_PUSH (symbeg);
 +              else if (c == '>')
 +                BUF_PUSH (symend);
 +              else
 +                FREE_STACK_RETURN (REG_BADPAT);
 +              break;
 +
 +          case 'b':
 +            BUF_PUSH (wordbound);
 +            break;
 +
 +          case 'B':
 +            BUF_PUSH (notwordbound);
 +            break;
 +
 +          case '`':
 +            BUF_PUSH (begbuf);
 +            break;
 +
 +          case '\'':
 +            BUF_PUSH (endbuf);
 +            break;
 +
 +          case '1': case '2': case '3': case '4': case '5':
 +          case '6': case '7': case '8': case '9':
 +            {
 +              regnum_t reg = c - '0';
 +
 +              if (reg > bufp->re_nsub || reg < 1
 +                  /* Can't back reference to a subexp before its end.  */
 +                  || group_in_compile_stack (compile_stack, reg))
 +                FREE_STACK_RETURN (REG_ESUBREG);
 +
 +              laststart = b;
 +              BUF_PUSH_2 (duplicate, reg);
 +            }
 +            break;
 +
 +          default:
 +            /* You might think it would be useful for \ to mean
 +               not to translate; but if we don't translate it
 +               it will never match anything.  */
 +            goto normal_char;
 +          }
 +        break;
 +
 +
 +      default:
 +      /* Expects the character in C.  */
 +      normal_char:
 +        /* If no exactn currently being built.  */
 +        if (!pending_exact
 +
 +            /* If last exactn not at current position.  */
 +            || pending_exact + *pending_exact + 1 != b
 +
 +            /* Only one byte follows the exactn for the count.  */
 +            || *pending_exact >= (1 << BYTEWIDTH) - MAX_MULTIBYTE_LENGTH
 +
 +            /* If followed by a repetition operator.  */
 +            || (p != pend
 +                && (*p == '*' || *p == '+' || *p == '?' || *p == '^'))
 +            || (p + 1 < pend && p[0] == '\\' && p[1] == '{'))
 +          {
 +            /* Start building a new exactn.  */
 +
 +            laststart = b;
 +
 +            BUF_PUSH_2 (exactn, 0);
 +            pending_exact = b - 1;
 +          }
 +
 +        GET_BUFFER_SPACE (MAX_MULTIBYTE_LENGTH);
 +        {
 +          int len;
 +
 +          if (multibyte)
 +            {
 +              c = TRANSLATE (c);
 +              len = CHAR_STRING (c, b);
 +              b += len;
 +            }
 +          else
 +            {
 +              c1 = RE_CHAR_TO_MULTIBYTE (c);
 +              if (! CHAR_BYTE8_P (c1))
 +                {
 +                  int c2 = TRANSLATE (c1);
 +
 +                  if (c1 != c2 && (c1 = RE_CHAR_TO_UNIBYTE (c2)) >= 0)
 +                    c = c1;
 +                }
 +              *b++ = c;
 +              len = 1;
 +            }
 +          (*pending_exact) += len;
 +        }
 +
 +        break;
 +      } /* switch (c) */
 +    } /* while p != pend */
 +
 +
 +  /* Through the pattern now.  */
 +
 +  FIXUP_ALT_JUMP ();
 +
 +  if (!COMPILE_STACK_EMPTY)
 +    FREE_STACK_RETURN (REG_EPAREN);
 +
 +  /* If we don't want backtracking, force success
 +     the first time we reach the end of the compiled pattern.  */
 +  if (!posix_backtracking)
 +    BUF_PUSH (succeed);
 +
 +  /* Success; set the length of the buffer.  */
 +  bufp->used = b - bufp->buffer;
 +
 +#ifdef REGEX_EMACS_DEBUG
 +  if (regex_emacs_debug > 0)
 +    {
 +      re_compile_fastmap (bufp);
 +      DEBUG_PRINT ("\nCompiled pattern: \n");
 +      print_compiled_pattern (bufp);
 +    }
 +  regex_emacs_debug--;
 +#endif
 +
 +  FREE_STACK_RETURN (REG_NOERROR);
 +
 +} /* regex_compile */
 +\f
 +/* Subroutines for 'regex_compile'.  */
 +
 +/* Store OP at LOC followed by two-byte integer parameter ARG.  */
 +
 +static void
 +store_op1 (re_opcode_t op, unsigned char *loc, int arg)
 +{
 +  *loc = (unsigned char) op;
 +  STORE_NUMBER (loc + 1, arg);
 +}
 +
 +
 +/* Like 'store_op1', but for two two-byte parameters ARG1 and ARG2.  */
 +
 +static void
 +store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2)
 +{
 +  *loc = (unsigned char) op;
 +  STORE_NUMBER (loc + 1, arg1);
 +  STORE_NUMBER (loc + 3, arg2);
 +}
 +
 +
 +/* Copy the bytes from LOC to END to open up three bytes of space at LOC
 +   for OP followed by two-byte integer parameter ARG.  */
 +
 +static void
 +insert_op1 (re_opcode_t op, unsigned char *loc, int arg, unsigned char *end)
 +{
 +  register unsigned char *pfrom = end;
 +  register unsigned char *pto = end + 3;
 +
 +  while (pfrom != loc)
 +    *--pto = *--pfrom;
 +
 +  store_op1 (op, loc, arg);
 +}
 +
 +
 +/* Like 'insert_op1', but for two two-byte parameters ARG1 and ARG2.  */
 +
 +static void
 +insert_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2,
 +          unsigned char *end)
 +{
 +  register unsigned char *pfrom = end;
 +  register unsigned char *pto = end + 5;
 +
 +  while (pfrom != loc)
 +    *--pto = *--pfrom;
 +
 +  store_op2 (op, loc, arg1, arg2);
 +}
 +
 +
 +/* P points to just after a ^ in PATTERN.  Return true if that ^ comes
 +   after an alternative or a begin-subexpression.  Assume there is at
 +   least one character before the ^.  */
 +
 +static bool
 +at_begline_loc_p (re_char *pattern, re_char *p)
 +{
 +  re_char *prev = p - 2;
 +
 +  switch (*prev)
 +    {
 +    case '(': /* After a subexpression.  */
 +    case '|': /* After an alternative.  */
 +      break;
 +
 +    case ':': /* After a shy subexpression.  */
 +      /* Skip over optional regnum.  */
 +      while (prev > pattern && '0' <= prev[-1] && prev[-1] <= '9')
 +      --prev;
 +
 +      if (! (prev > pattern + 1 && prev[-1] == '?' && prev[-2] == '('))
 +      return false;
 +      prev -= 2;
 +      break;
 +
 +    default:
 +      return false;
 +    }
 +
 +  /* Count the number of preceding backslashes.  */
 +  p = prev;
 +  while (prev > pattern && prev[-1] == '\\')
 +    --prev;
 +  return (p - prev) & 1;
 +}
 +
 +
 +/* The dual of at_begline_loc_p.  This one is for $.  Assume there is
 +   at least one character after the $, i.e., 'P < PEND'.  */
 +
 +static bool
 +at_endline_loc_p (re_char *p, re_char *pend)
 +{
 +  /* Before a subexpression or an alternative?  */
 +  return *p == '\\' && p + 1 < pend && (p[1] == ')' || p[1] == '|');
 +}
 +
 +
 +/* Returns true if REGNUM is in one of COMPILE_STACK's elements and
 +   false if it's not.  */
 +
 +static bool
 +group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
 +{
 +  ptrdiff_t this_element;
 +
 +  for (this_element = compile_stack.avail - 1;
 +       this_element >= 0;
 +       this_element--)
 +    if (compile_stack.stack[this_element].regnum == regnum)
 +      return true;
 +
 +  return false;
 +}
 +\f
 +/* analyze_first.
 +   If fastmap is non-NULL, go through the pattern and fill fastmap
 +   with all the possible leading chars.  If fastmap is NULL, don't
 +   bother filling it up (obviously) and only return whether the
 +   pattern could potentially match the empty string.
 +
 +   Return 1  if p..pend might match the empty string.
 +   Return 0  if p..pend matches at least one char.
 +   Return -1 if fastmap was not updated accurately.  */
 +
 +static int
 +analyze_first (re_char *p, re_char *pend, char *fastmap,
 +             const int multibyte)
 +{
 +  int j, k;
 +  bool not;
 +
 +  /* If all elements for base leading-codes in fastmap is set, this
 +     flag is set true.  */
 +  bool match_any_multibyte_characters = false;
 +
 +  eassert (p);
 +
 +  /* The loop below works as follows:
 +     - It has a working-list kept in the PATTERN_STACK and which basically
 +       starts by only containing a pointer to the first operation.
 +     - If the opcode we're looking at is a match against some set of
 +       chars, then we add those chars to the fastmap and go on to the
 +       next work element from the worklist (done via 'break').
 +     - If the opcode is a control operator on the other hand, we either
 +       ignore it (if it's meaningless at this point, such as 'start_memory')
 +       or execute it (if it's a jump).  If the jump has several destinations
 +       (i.e. 'on_failure_jump'), then we push the other destination onto the
 +       worklist.
 +     We guarantee termination by ignoring backward jumps (more or less),
 +     so that P is monotonically increasing.  More to the point, we
 +     never set P (or push) anything '<= p1'.  */
 +
 +  while (p < pend)
 +    {
 +      /* P1 is used as a marker of how far back a 'on_failure_jump'
 +       can go without being ignored.  It is normally equal to P
 +       (which prevents any backward 'on_failure_jump') except right
 +       after a plain 'jump', to allow patterns such as:
 +          0: jump 10
 +          3..9: <body>
 +          10: on_failure_jump 3
 +       as used for the *? operator.  */
 +      re_char *p1 = p;
 +
 +      switch (*p++)
 +      {
 +      case succeed:
 +        return 1;
 +
 +      case duplicate:
 +        /* If the first character has to match a backreference, that means
 +           that the group was empty (since it already matched).  Since this
 +           is the only case that interests us here, we can assume that the
 +           backreference must match the empty string.  */
 +        p++;
 +        continue;
 +
 +
 +      /* Following are the cases which match a character.  These end
 +       with 'break'.  */
 +
 +      case exactn:
 +        if (fastmap)
 +          {
 +            /* If multibyte is nonzero, the first byte of each
 +               character is an ASCII or a leading code.  Otherwise,
 +               each byte is a character.  Thus, this works in both
 +               cases. */
 +            fastmap[p[1]] = 1;
 +            if (! multibyte)
 +              {
 +                /* For the case of matching this unibyte regex
 +                   against multibyte, we must set a leading code of
 +                   the corresponding multibyte character.  */
 +                int c = RE_CHAR_TO_MULTIBYTE (p[1]);
 +
 +                fastmap[CHAR_LEADING_CODE (c)] = 1;
 +              }
 +          }
 +        break;
 +
 +
 +      case anychar:
 +        /* We could put all the chars except for \n (and maybe \0)
 +           but we don't bother since it is generally not worth it.  */
 +        if (!fastmap) break;
 +        return -1;
 +
 +
 +      case charset_not:
 +        if (!fastmap) break;
 +        {
 +          /* Chars beyond end of bitmap are possible matches.  */
 +          for (j = CHARSET_BITMAP_SIZE (&p[-1]) * BYTEWIDTH;
 +               j < (1 << BYTEWIDTH); j++)
 +            fastmap[j] = 1;
 +        }
 +        FALLTHROUGH;
 +      case charset:
 +        if (!fastmap) break;
 +        not = (re_opcode_t) *(p - 1) == charset_not;
 +        for (j = CHARSET_BITMAP_SIZE (&p[-1]) * BYTEWIDTH - 1, p++;
 +             j >= 0; j--)
 +          if (!!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) ^ not)
 +            fastmap[j] = 1;
 +
 +        if (/* Any leading code can possibly start a character
 +               which doesn't match the specified set of characters.  */
 +            not
 +            ||
 +            /* If we can match a character class, we can match any
 +               multibyte characters.  */
 +            (CHARSET_RANGE_TABLE_EXISTS_P (&p[-2])
 +             && CHARSET_RANGE_TABLE_BITS (&p[-2]) != 0))
 +
 +          {
 +            if (match_any_multibyte_characters == false)
 +              {
 +                for (j = MIN_MULTIBYTE_LEADING_CODE;
 +                     j <= MAX_MULTIBYTE_LEADING_CODE; j++)
 +                  fastmap[j] = 1;
 +                match_any_multibyte_characters = true;
 +              }
 +          }
 +
 +        else if (!not && CHARSET_RANGE_TABLE_EXISTS_P (&p[-2])
 +                 && match_any_multibyte_characters == false)
 +          {
 +            /* Set fastmap[I] to 1 where I is a leading code of each
 +               multibyte character in the range table. */
 +            int c, count;
 +            unsigned char lc1, lc2;
 +
 +            /* Make P points the range table.  '+ 2' is to skip flag
 +               bits for a character class.  */
 +            p += CHARSET_BITMAP_SIZE (&p[-2]) + 2;
 +
 +            /* Extract the number of ranges in range table into COUNT.  */
 +            EXTRACT_NUMBER_AND_INCR (count, p);
 +            for (; count > 0; count--, p += 3)
 +              {
 +                /* Extract the start and end of each range.  */
 +                EXTRACT_CHARACTER (c, p);
 +                lc1 = CHAR_LEADING_CODE (c);
 +                p += 3;
 +                EXTRACT_CHARACTER (c, p);
 +                lc2 = CHAR_LEADING_CODE (c);
 +                for (j = lc1; j <= lc2; j++)
 +                  fastmap[j] = 1;
 +              }
 +          }
 +        break;
 +
 +      case syntaxspec:
 +      case notsyntaxspec:
 +        if (!fastmap) break;
 +        /* This match depends on text properties.  These end with
 +           aborting optimizations.  */
 +        return -1;
 +
 +      case categoryspec:
 +      case notcategoryspec:
 +        if (!fastmap) break;
 +        not = (re_opcode_t)p[-1] == notcategoryspec;
 +        k = *p++;
 +        for (j = (1 << BYTEWIDTH); j >= 0; j--)
 +          if ((CHAR_HAS_CATEGORY (j, k)) ^ not)
 +            fastmap[j] = 1;
 +
 +        /* Any leading code can possibly start a character which
 +           has or doesn't has the specified category.  */
 +        if (match_any_multibyte_characters == false)
 +          {
 +            for (j = MIN_MULTIBYTE_LEADING_CODE;
 +                 j <= MAX_MULTIBYTE_LEADING_CODE; j++)
 +              fastmap[j] = 1;
 +            match_any_multibyte_characters = true;
 +          }
 +        break;
 +
 +      /* All cases after this match the empty string.  These end with
 +       'continue'.  */
 +
 +      case at_dot:
 +      case no_op:
 +      case begline:
 +      case endline:
 +      case begbuf:
 +      case endbuf:
 +      case wordbound:
 +      case notwordbound:
 +      case wordbeg:
 +      case wordend:
 +      case symbeg:
 +      case symend:
 +        continue;
 +
 +
 +      case jump:
 +        EXTRACT_NUMBER_AND_INCR (j, p);
 +        if (j < 0)
 +          /* Backward jumps can only go back to code that we've already
 +             visited.  're_compile' should make sure this is true.  */
 +          break;
 +        p += j;
 +        switch (*p)
 +          {
 +          case on_failure_jump:
 +          case on_failure_keep_string_jump:
 +          case on_failure_jump_loop:
 +          case on_failure_jump_nastyloop:
 +          case on_failure_jump_smart:
 +            p++;
 +            break;
 +          default:
 +            continue;
 +          };
 +        /* Keep P1 to allow the 'on_failure_jump' we are jumping to
 +           to jump back to "just after here".  */
 +        FALLTHROUGH;
 +      case on_failure_jump:
 +      case on_failure_keep_string_jump:
 +      case on_failure_jump_nastyloop:
 +      case on_failure_jump_loop:
 +      case on_failure_jump_smart:
 +        EXTRACT_NUMBER_AND_INCR (j, p);
 +        if (p + j <= p1)
 +          ; /* Backward jump to be ignored.  */
 +        else
 +          { /* We have to look down both arms.
 +               We first go down the "straight" path so as to minimize
 +               stack usage when going through alternatives.  */
 +            int r = analyze_first (p, pend, fastmap, multibyte);
 +            if (r) return r;
 +            p += j;
 +          }
 +        continue;
 +
 +
 +      case jump_n:
 +        /* This code simply does not properly handle forward jump_n.  */
 +        DEBUG_STATEMENT (EXTRACT_NUMBER (j, p); eassert (j < 0));
 +        p += 4;
 +        /* jump_n can either jump or fall through.  The (backward) jump
 +           case has already been handled, so we only need to look at the
 +           fallthrough case.  */
 +        continue;
 +
 +      case succeed_n:
 +        /* If N == 0, it should be an on_failure_jump_loop instead.  */
 +        DEBUG_STATEMENT (EXTRACT_NUMBER (j, p + 2); eassert (j > 0));
 +        p += 4;
 +        /* We only care about one iteration of the loop, so we don't
 +           need to consider the case where this behaves like an
 +           on_failure_jump.  */
 +        continue;
 +
 +
 +      case set_number_at:
 +        p += 4;
 +        continue;
 +
 +
 +      case start_memory:
 +      case stop_memory:
 +        p += 1;
 +        continue;
 +
 +
 +      default:
 +        abort (); /* We have listed all the cases.  */
 +      } /* switch *p++ */
 +
 +      /* Getting here means we have found the possible starting
 +       characters for one path of the pattern -- and that the empty
 +       string does not match.  We need not follow this path further.  */
 +      return 0;
 +    } /* while p */
 +
 +  /* We reached the end without matching anything.  */
 +  return 1;
 +
 +} /* analyze_first */
 +\f
 +/* Compute a fastmap for the compiled pattern in BUFP.
 +   A fastmap records which of the (1 << BYTEWIDTH) possible
 +   characters can start a string that matches the pattern.  This fastmap
 +   is used by re_search to skip quickly over impossible starting points.
 +
 +   Character codes above (1 << BYTEWIDTH) are not represented in the
 +   fastmap, but the leading codes are represented.  Thus, the fastmap
 +   indicates which character sets could start a match.
 +
 +   The caller must supply the address of a (1 << BYTEWIDTH)-byte data
 +   area as BUFP->fastmap.
 +
 +   Set the 'fastmap', 'fastmap_accurate', and 'can_be_null' fields in
 +   the pattern buffer.  */
 +
 +static void
 +re_compile_fastmap (struct re_pattern_buffer *bufp)
 +{
 +  char *fastmap = bufp->fastmap;
 +  int analysis;
 +
 +  eassert (fastmap && bufp->buffer);
 +
 +  memset (fastmap, 0, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
 +  bufp->fastmap_accurate = 1;     /* It will be when we're done.  */
 +
 +  analysis = analyze_first (bufp->buffer, bufp->buffer + bufp->used,
 +                          fastmap, RE_MULTIBYTE_P (bufp));
 +  bufp->can_be_null = (analysis != 0);
 +} /* re_compile_fastmap */
 +\f
 +/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
 +   ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use
 +   this memory for recording register information.  STARTS and ENDS
 +   must be allocated using the malloc library routine, and must each
 +   be at least NUM_REGS * sizeof (ptrdiff_t) bytes long.
 +
 +   If NUM_REGS == 0, then subsequent matches should allocate their own
 +   register data.
 +
 +   Unless this function is called, the first search or match using
 +   PATTERN_BUFFER will allocate its own register data, without
 +   freeing the old data.  */
 +
 +void
 +re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs,
 +                unsigned int num_regs, ptrdiff_t *starts, ptrdiff_t *ends)
 +{
 +  if (num_regs)
 +    {
 +      bufp->regs_allocated = REGS_REALLOCATE;
 +      regs->num_regs = num_regs;
 +      regs->start = starts;
 +      regs->end = ends;
 +    }
 +  else
 +    {
 +      bufp->regs_allocated = REGS_UNALLOCATED;
 +      regs->num_regs = 0;
 +      regs->start = regs->end = 0;
 +    }
 +}
 +\f
 +/* Searching routines.  */
 +
 +/* Like re_search_2, below, but only one string is specified, and
 +   doesn't let you say where to stop matching. */
 +
 +ptrdiff_t
 +re_search (struct re_pattern_buffer *bufp, const char *string, size_t size,
 +         ptrdiff_t startpos, ptrdiff_t range, struct re_registers *regs)
 +{
 +  return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
 +                    regs, size);
 +}
 +
 +/* Head address of virtual concatenation of string.  */
 +#define HEAD_ADDR_VSTRING(P)          \
 +  (((P) >= size1 ? string2 : string1))
 +
 +/* Address of POS in the concatenation of virtual string. */
 +#define POS_ADDR_VSTRING(POS)                                 \
 +  (((POS) >= size1 ? string2 - size1 : string1) + (POS))
 +
 +/* Using the compiled pattern in BUFP->buffer, first tries to match the
 +   virtual concatenation of STRING1 and STRING2, starting first at index
 +   STARTPOS, then at STARTPOS + 1, and so on.
 +
 +   STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
 +
 +   RANGE is how far to scan while trying to match.  RANGE = 0 means try
 +   only at STARTPOS; in general, the last start tried is STARTPOS +
 +   RANGE.
 +
 +   In REGS, return the indices of the virtual concatenation of STRING1
 +   and STRING2 that matched the entire BUFP->buffer and its contained
 +   subexpressions.
 +
 +   Do not consider matching one past the index STOP in the virtual
 +   concatenation of STRING1 and STRING2.
 +
 +   Return either the position in the strings at which the match was
 +   found, -1 if no match, or -2 if error (such as failure
 +   stack overflow).  */
 +
 +ptrdiff_t
 +re_search_2 (struct re_pattern_buffer *bufp, const char *str1, size_t size1,
 +           const char *str2, size_t size2,
 +           ptrdiff_t startpos, ptrdiff_t range,
 +           struct re_registers *regs, ptrdiff_t stop)
 +{
 +  ptrdiff_t val;
 +  re_char *string1 = (re_char *) str1;
 +  re_char *string2 = (re_char *) str2;
 +  char *fastmap = bufp->fastmap;
 +  Lisp_Object translate = bufp->translate;
 +  size_t total_size = size1 + size2;
 +  ptrdiff_t endpos = startpos + range;
 +  bool anchored_start;
 +  /* Nonzero if we are searching multibyte string.  */
 +  bool multibyte = RE_TARGET_MULTIBYTE_P (bufp);
 +
 +  /* Check for out-of-range STARTPOS.  */
 +  if (startpos < 0 || startpos > total_size)
 +    return -1;
 +
 +  /* Fix up RANGE if it might eventually take us outside
 +     the virtual concatenation of STRING1 and STRING2.
 +     Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE.  */
 +  if (endpos < 0)
 +    range = 0 - startpos;
 +  else if (endpos > total_size)
 +    range = total_size - startpos;
 +
 +  /* If the search isn't to be a backwards one, don't waste time in a
 +     search for a pattern anchored at beginning of buffer.  */
 +  if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0)
 +    {
 +      if (startpos > 0)
 +      return -1;
 +      else
 +      range = 0;
 +    }
 +
 +  /* In a forward search for something that starts with \=.
 +     don't keep searching past point.  */
 +  if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0)
 +    {
 +      range = PT_BYTE - BEGV_BYTE - startpos;
 +      if (range < 0)
 +      return -1;
 +    }
 +
 +  /* Update the fastmap now if not correct already.  */
 +  if (fastmap && !bufp->fastmap_accurate)
 +    re_compile_fastmap (bufp);
 +
 +  /* See whether the pattern is anchored.  */
 +  anchored_start = (bufp->buffer[0] == begline);
 +
 +  gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
 +  {
 +    ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (startpos));
 +
 +    SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
 +  }
 +
 +  /* Loop through the string, looking for a place to start matching.  */
 +  for (;;)
 +    {
 +      /* If the pattern is anchored,
 +       skip quickly past places we cannot match.
 +       Don't bother to treat startpos == 0 specially
 +       because that case doesn't repeat.  */
 +      if (anchored_start && startpos > 0)
 +      {
 +        if (! ((startpos <= size1 ? string1[startpos - 1]
 +                : string2[startpos - size1 - 1])
 +               == '\n'))
 +          goto advance;
 +      }
 +
 +      /* If a fastmap is supplied, skip quickly over characters that
 +       cannot be the start of a match.  If the pattern can match the
 +       null string, however, we don't need to skip characters; we want
 +       the first null string.  */
 +      if (fastmap && startpos < total_size && !bufp->can_be_null)
 +      {
 +        re_char *d;
 +        int buf_ch;
 +
 +        d = POS_ADDR_VSTRING (startpos);
 +
 +        if (range > 0)        /* Searching forwards.  */
 +          {
 +            ptrdiff_t irange = range, lim = 0;
 +
 +            if (startpos < size1 && startpos + range >= size1)
 +              lim = range - (size1 - startpos);
 +
 +            /* Written out as an if-else to avoid testing 'translate'
 +               inside the loop.  */
 +            if (!NILP (translate))
 +              {
 +                if (multibyte)
 +                  while (range > lim)
 +                    {
 +                      int buf_charlen;
 +
 +                      buf_ch = STRING_CHAR_AND_LENGTH (d, buf_charlen);
 +                      buf_ch = RE_TRANSLATE (translate, buf_ch);
 +                      if (fastmap[CHAR_LEADING_CODE (buf_ch)])
 +                        break;
 +
 +                      range -= buf_charlen;
 +                      d += buf_charlen;
 +                    }
 +                else
 +                  while (range > lim)
 +                    {
 +                      buf_ch = *d;
 +                      int ch = RE_CHAR_TO_MULTIBYTE (buf_ch);
 +                      int translated = RE_TRANSLATE (translate, ch);
 +                      if (translated != ch
 +                          && (ch = RE_CHAR_TO_UNIBYTE (translated)) >= 0)
 +                        buf_ch = ch;
 +                      if (fastmap[buf_ch])
 +                        break;
 +                      d++;
 +                      range--;
 +                    }
 +              }
 +            else
 +              {
 +                if (multibyte)
 +                  while (range > lim)
 +                    {
 +                      int buf_charlen;
 +
 +                      buf_ch = STRING_CHAR_AND_LENGTH (d, buf_charlen);
 +                      if (fastmap[CHAR_LEADING_CODE (buf_ch)])
 +                        break;
 +                      range -= buf_charlen;
 +                      d += buf_charlen;
 +                    }
 +                else
 +                  while (range > lim && !fastmap[*d])
 +                    {
 +                      d++;
 +                      range--;
 +                    }
 +              }
 +            startpos += irange - range;
 +          }
 +        else                          /* Searching backwards.  */
 +          {
 +            if (multibyte)
 +              {
 +                buf_ch = STRING_CHAR (d);
 +                buf_ch = TRANSLATE (buf_ch);
 +                if (! fastmap[CHAR_LEADING_CODE (buf_ch)])
 +                  goto advance;
 +              }
 +            else
 +              {
 +                buf_ch = *d;
 +                int ch = RE_CHAR_TO_MULTIBYTE (buf_ch);
 +                int translated = TRANSLATE (ch);
 +                if (translated != ch
 +                    && (ch = RE_CHAR_TO_UNIBYTE (translated)) >= 0)
 +                  buf_ch = ch;
 +                if (! fastmap[TRANSLATE (buf_ch)])
 +                  goto advance;
 +              }
 +          }
 +      }
 +
 +      /* If can't match the null string, and that's all we have left, fail.  */
 +      if (range >= 0 && startpos == total_size && fastmap
 +        && !bufp->can_be_null)
 +      return -1;
 +
 +      val = re_match_2_internal (bufp, string1, size1, string2, size2,
 +                               startpos, regs, stop);
 +
 +      if (val >= 0)
 +      return startpos;
 +
 +      if (val == -2)
 +      return -2;
 +
 +    advance:
 +      if (!range)
 +      break;
 +      else if (range > 0)
 +      {
 +        /* Update STARTPOS to the next character boundary.  */
 +        if (multibyte)
 +          {
 +            re_char *p = POS_ADDR_VSTRING (startpos);
 +            int len = BYTES_BY_CHAR_HEAD (*p);
 +
 +            range -= len;
 +            if (range < 0)
 +              break;
 +            startpos += len;
 +          }
 +        else
 +          {
 +            range--;
 +            startpos++;
 +          }
 +      }
 +      else
 +      {
 +        range++;
 +        startpos--;
 +
 +        /* Update STARTPOS to the previous character boundary.  */
 +        if (multibyte)
 +          {
 +            re_char *p = POS_ADDR_VSTRING (startpos) + 1;
 +            re_char *p0 = p;
 +            re_char *phead = HEAD_ADDR_VSTRING (startpos);
 +
 +            /* Find the head of multibyte form.  */
 +            PREV_CHAR_BOUNDARY (p, phead);
 +            range += p0 - 1 - p;
 +            if (range > 0)
 +              break;
 +
 +            startpos -= p0 - 1 - p;
 +          }
 +      }
 +    }
 +  return -1;
 +} /* re_search_2 */
 +\f
 +/* Declarations and macros for re_match_2.  */
 +
 +static int bcmp_translate (re_char *s1, re_char *s2,
 +                         ptrdiff_t len,
 +                         Lisp_Object translate,
 +                         const int multibyte);
 +
 +/* This converts PTR, a pointer into one of the search strings 'string1'
 +   and 'string2' into an offset from the beginning of that string.  */
 +#define POINTER_TO_OFFSET(ptr)                        \
 +  (FIRST_STRING_P (ptr)                               \
 +   ? (ptr) - string1                          \
 +   : (ptr) - string2 + (ptrdiff_t) size1)
 +
 +/* Call before fetching a character with *d.  This switches over to
 +   string2 if necessary.
 +   Check re_match_2_internal for a discussion of why end_match_2 might
 +   not be within string2 (but be equal to end_match_1 instead).  */
 +#define PREFETCH()                                                    \
 +  while (d == dend)                                                   \
 +    {                                                                 \
 +      /* End of string2 => fail.  */                                  \
 +      if (dend == end_match_2)                                                \
 +      goto fail;                                                      \
 +      /* End of string1 => advance to string2.  */                    \
 +      d = string2;                                                    \
 +      dend = end_match_2;                                             \
 +    }
 +
 +/* Call before fetching a char with *d if you already checked other limits.
 +   This is meant for use in lookahead operations like wordend, etc..
 +   where we might need to look at parts of the string that might be
 +   outside of the LIMITs (i.e past 'stop').  */
 +#define PREFETCH_NOLIMIT()                                            \
 +  if (d == end1)                                                      \
 +     {                                                                        \
 +       d = string2;                                                   \
 +       dend = end_match_2;                                            \
 +     }                                                                        \
 +
 +/* Test if at very beginning or at very end of the virtual concatenation
 +   of STRING1 and STRING2.  If only one string, it's STRING2.  */
 +#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
 +#define AT_STRINGS_END(d) ((d) == end2)
 +
 +/* Disabled due to a compiler bug -- see comment at case wordbound */
 +
 +/* The comment at case wordbound is following one, but we don't use
 +   AT_WORD_BOUNDARY anymore to support multibyte form.
 +
 +   The DEC Alpha C compiler 3.x generates incorrect code for the
 +   test        WORDCHAR_P (d - 1) != WORDCHAR_P (d)  in the expansion of
 +   AT_WORD_BOUNDARY, so this code is disabled.  Expanding the
 +   macro and introducing temporary variables works around the bug.  */
 +
 +#if 0
 +/* Test if D points to a character which is word-constituent.  We have
 +   two special cases to check for: if past the end of string1, look at
 +   the first character in string2; and if before the beginning of
 +   string2, look at the last character in string1.  */
 +#define WORDCHAR_P(d)                                                 \
 +  (SYNTAX ((d) == end1 ? *string2                                     \
 +         : (d) == string2 - 1 ? *(end1 - 1) : *(d))                   \
 +   == Sword)
 +
 +/* Test if the character before D and the one at D differ with respect
 +   to being word-constituent.  */
 +#define AT_WORD_BOUNDARY(d)                                           \
 +  (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)                           \
 +   || WORDCHAR_P (d - 1) != WORDCHAR_P (d))
 +#endif
 +
 +\f
 +/* Optimization routines.  */
 +
 +/* If the operation is a match against one or more chars,
 +   return a pointer to the next operation, else return NULL.  */
 +static re_char *
 +skip_one_char (re_char *p)
 +{
 +  switch (*p++)
 +    {
 +    case anychar:
 +      break;
 +
 +    case exactn:
 +      p += *p + 1;
 +      break;
 +
 +    case charset_not:
 +    case charset:
 +      if (CHARSET_RANGE_TABLE_EXISTS_P (p - 1))
 +      {
 +        int mcnt;
 +        p = CHARSET_RANGE_TABLE (p - 1);
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        p = CHARSET_RANGE_TABLE_END (p, mcnt);
 +      }
 +      else
 +      p += 1 + CHARSET_BITMAP_SIZE (p - 1);
 +      break;
 +
 +    case syntaxspec:
 +    case notsyntaxspec:
 +    case categoryspec:
 +    case notcategoryspec:
 +      p++;
 +      break;
 +
 +    default:
 +      p = NULL;
 +    }
 +  return p;
 +}
 +
 +
 +/* Jump over non-matching operations.  */
 +static re_char *
 +skip_noops (re_char *p, re_char *pend)
 +{
 +  int mcnt;
 +  while (p < pend)
 +    {
 +      switch (*p)
 +      {
 +      case start_memory:
 +      case stop_memory:
 +        p += 2; break;
 +      case no_op:
 +        p += 1; break;
 +      case jump:
 +        p += 1;
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        p += mcnt;
 +        break;
 +      default:
 +        return p;
 +      }
 +    }
 +  eassert (p == pend);
 +  return p;
 +}
 +
 +/* Test if C matches charset op.  *PP points to the charset or charset_not
 +   opcode.  When the function finishes, *PP will be advanced past that opcode.
 +   C is character to test (possibly after translations) and CORIG is original
 +   character (i.e. without any translations).  UNIBYTE denotes whether c is
 +   unibyte or multibyte character. */
 +static bool
 +execute_charset (re_char **pp, unsigned c, unsigned corig, bool unibyte)
 +{
 +  re_char *p = *pp, *rtp = NULL;
 +  bool not = (re_opcode_t) *p == charset_not;
 +
 +  if (CHARSET_RANGE_TABLE_EXISTS_P (p))
 +    {
 +      int count;
 +      rtp = CHARSET_RANGE_TABLE (p);
 +      EXTRACT_NUMBER_AND_INCR (count, rtp);
 +      *pp = CHARSET_RANGE_TABLE_END ((rtp), (count));
 +    }
 +  else
 +    *pp += 2 + CHARSET_BITMAP_SIZE (p);
 +
 +  if (unibyte && c < (1 << BYTEWIDTH))
 +    {                 /* Lookup bitmap.  */
 +      /* Cast to 'unsigned' instead of 'unsigned char' in
 +       case the bit list is a full 32 bytes long.  */
 +      if (c < (unsigned) (CHARSET_BITMAP_SIZE (p) * BYTEWIDTH)
 +        && p[2 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
 +      return !not;
 +    }
 +  else if (rtp)
 +    {
 +      int class_bits = CHARSET_RANGE_TABLE_BITS (p);
 +      int range_start, range_end;
 +
 +  /* Sort tests by the most commonly used classes with some adjustment to which
 +     tests are easiest to perform.  Take a look at comment in re_wctype_parse
 +     for table with frequencies of character class names. */
 +
 +      if ((class_bits & BIT_MULTIBYTE) ||
 +        (class_bits & BIT_ALNUM && ISALNUM (c)) ||
 +        (class_bits & BIT_ALPHA && ISALPHA (c)) ||
 +        (class_bits & BIT_SPACE && ISSPACE (c)) ||
 +          (class_bits & BIT_BLANK && ISBLANK (c)) ||
 +        (class_bits & BIT_WORD  && ISWORD  (c)) ||
 +        ((class_bits & BIT_UPPER) &&
 +         (ISUPPER (c) || (corig != c &&
 +                          c == downcase (corig) && ISLOWER (c)))) ||
 +        ((class_bits & BIT_LOWER) &&
 +         (ISLOWER (c) || (corig != c &&
 +                          c == upcase (corig) && ISUPPER(c)))) ||
 +        (class_bits & BIT_PUNCT && ISPUNCT (c)) ||
 +        (class_bits & BIT_GRAPH && ISGRAPH (c)) ||
 +        (class_bits & BIT_PRINT && ISPRINT (c)))
 +      return !not;
 +
 +      for (p = *pp; rtp < p; rtp += 2 * 3)
 +      {
 +        EXTRACT_CHARACTER (range_start, rtp);
 +        EXTRACT_CHARACTER (range_end, rtp + 3);
 +        if (range_start <= c && c <= range_end)
 +          return !not;
 +      }
 +    }
 +
 +  return not;
 +}
 +
 +/* Non-zero if "p1 matches something" implies "p2 fails".  */
 +static int
 +mutually_exclusive_p (struct re_pattern_buffer *bufp, re_char *p1,
 +                    re_char *p2)
 +{
 +  re_opcode_t op2;
 +  bool multibyte = RE_MULTIBYTE_P (bufp);
 +  unsigned char *pend = bufp->buffer + bufp->used;
 +
 +  eassert (p1 >= bufp->buffer && p1 < pend
 +         && p2 >= bufp->buffer && p2 <= pend);
 +
 +  /* Skip over open/close-group commands.
 +     If what follows this loop is a ...+ construct,
 +     look at what begins its body, since we will have to
 +     match at least one of that.  */
 +  p2 = skip_noops (p2, pend);
 +  /* The same skip can be done for p1, except that this function
 +     is only used in the case where p1 is a simple match operator.  */
 +  /* p1 = skip_noops (p1, pend); */
 +
 +  eassert (p1 >= bufp->buffer && p1 < pend
 +         && p2 >= bufp->buffer && p2 <= pend);
 +
 +  op2 = p2 == pend ? succeed : *p2;
 +
 +  switch (op2)
 +    {
 +    case succeed:
 +    case endbuf:
 +      /* If we're at the end of the pattern, we can change.  */
 +      if (skip_one_char (p1))
 +      {
 +        DEBUG_PRINT ("  End of pattern: fast loop.\n");
 +        return 1;
 +      }
 +      break;
 +
 +    case endline:
 +    case exactn:
 +      {
 +      int c
 +        = (re_opcode_t) *p2 == endline ? '\n'
 +        : RE_STRING_CHAR (p2 + 2, multibyte);
 +
 +      if ((re_opcode_t) *p1 == exactn)
 +        {
 +          if (c != RE_STRING_CHAR (p1 + 2, multibyte))
 +            {
 +              DEBUG_PRINT ("  '%c' != '%c' => fast loop.\n", c, p1[2]);
 +              return 1;
 +            }
 +        }
 +
 +      else if ((re_opcode_t) *p1 == charset
 +               || (re_opcode_t) *p1 == charset_not)
 +        {
 +          if (!execute_charset (&p1, c, c, !multibyte || ASCII_CHAR_P (c)))
 +            {
 +              DEBUG_PRINT ("   No match => fast loop.\n");
 +              return 1;
 +            }
 +        }
 +      else if ((re_opcode_t) *p1 == anychar
 +               && c == '\n')
 +        {
 +          DEBUG_PRINT ("   . != \\n => fast loop.\n");
 +          return 1;
 +        }
 +      }
 +      break;
 +
 +    case charset:
 +      {
 +      if ((re_opcode_t) *p1 == exactn)
 +        /* Reuse the code above.  */
 +        return mutually_exclusive_p (bufp, p2, p1);
 +
 +      /* It is hard to list up all the character in charset
 +       P2 if it includes multibyte character.  Give up in
 +       such case.  */
 +      else if (!multibyte || !CHARSET_RANGE_TABLE_EXISTS_P (p2))
 +      {
 +        /* Now, we are sure that P2 has no range table.
 +           So, for the size of bitmap in P2, 'p2[1]' is
 +           enough.  But P1 may have range table, so the
 +           size of bitmap table of P1 is extracted by
 +           using macro 'CHARSET_BITMAP_SIZE'.
 +
 +           In a multibyte case, we know that all the character
 +           listed in P2 is ASCII.  In a unibyte case, P1 has only a
 +           bitmap table.  So, in both cases, it is enough to test
 +           only the bitmap table of P1.  */
 +
 +        if ((re_opcode_t) *p1 == charset)
 +          {
 +            int idx;
 +            /* We win if the charset inside the loop
 +               has no overlap with the one after the loop.  */
 +            for (idx = 0;
 +                 (idx < (int) p2[1]
 +                  && idx < CHARSET_BITMAP_SIZE (p1));
 +                 idx++)
 +              if ((p2[2 + idx] & p1[2 + idx]) != 0)
 +                break;
 +
 +            if (idx == p2[1]
 +                || idx == CHARSET_BITMAP_SIZE (p1))
 +              {
 +                DEBUG_PRINT ("         No match => fast loop.\n");
 +                return 1;
 +              }
 +          }
 +        else if ((re_opcode_t) *p1 == charset_not)
 +          {
 +            int idx;
 +            /* We win if the charset_not inside the loop lists
 +               every character listed in the charset after.  */
 +            for (idx = 0; idx < (int) p2[1]; idx++)
 +              if (! (p2[2 + idx] == 0
 +                     || (idx < CHARSET_BITMAP_SIZE (p1)
 +                         && ((p2[2 + idx] & ~ p1[2 + idx]) == 0))))
 +                break;
 +
 +            if (idx == p2[1])
 +              {
 +                DEBUG_PRINT ("         No match => fast loop.\n");
 +                return 1;
 +              }
 +            }
 +        }
 +      }
 +      break;
 +
 +    case charset_not:
 +      switch (*p1)
 +      {
 +      case exactn:
 +      case charset:
 +        /* Reuse the code above.  */
 +        return mutually_exclusive_p (bufp, p2, p1);
 +      case charset_not:
 +        /* When we have two charset_not, it's very unlikely that
 +           they don't overlap.  The union of the two sets of excluded
 +           chars should cover all possible chars, which, as a matter of
 +           fact, is virtually impossible in multibyte buffers.  */
 +        break;
 +      }
 +      break;
 +
 +    case wordend:
 +      return ((re_opcode_t) *p1 == syntaxspec && p1[1] == Sword);
 +    case symend:
 +      return ((re_opcode_t) *p1 == syntaxspec
 +              && (p1[1] == Ssymbol || p1[1] == Sword));
 +    case notsyntaxspec:
 +      return ((re_opcode_t) *p1 == syntaxspec && p1[1] == p2[1]);
 +
 +    case wordbeg:
 +      return ((re_opcode_t) *p1 == notsyntaxspec && p1[1] == Sword);
 +    case symbeg:
 +      return ((re_opcode_t) *p1 == notsyntaxspec
 +              && (p1[1] == Ssymbol || p1[1] == Sword));
 +    case syntaxspec:
 +      return ((re_opcode_t) *p1 == notsyntaxspec && p1[1] == p2[1]);
 +
 +    case wordbound:
 +      return (((re_opcode_t) *p1 == notsyntaxspec
 +             || (re_opcode_t) *p1 == syntaxspec)
 +            && p1[1] == Sword);
 +
 +    case categoryspec:
 +      return ((re_opcode_t) *p1 == notcategoryspec && p1[1] == p2[1]);
 +    case notcategoryspec:
 +      return ((re_opcode_t) *p1 == categoryspec && p1[1] == p2[1]);
 +
 +    default:
 +      ;
 +    }
 +
 +  /* Safe default.  */
 +  return 0;
 +}
 +
 +\f
 +/* Matching routines.  */
 +
 +/* re_match_2 matches the compiled pattern in BUFP against the
 +   the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
 +   and SIZE2, respectively).  We start matching at POS, and stop
 +   matching at STOP.
 +
 +   If REGS is non-null, store offsets for the substring each group
 +   matched in REGS.
 +
 +   We return -1 if no match, -2 if an internal error (such as the
 +   failure stack overflowing).  Otherwise, we return the length of the
 +   matched substring.  */
 +
 +ptrdiff_t
 +re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
 +          size_t size1, const char *string2, size_t size2, ptrdiff_t pos,
 +          struct re_registers *regs, ptrdiff_t stop)
 +{
 +  ptrdiff_t result;
 +
 +  ptrdiff_t charpos;
 +  gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
 +  charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (pos));
 +  SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
 +
 +  result = re_match_2_internal (bufp, (re_char *) string1, size1,
 +                              (re_char *) string2, size2,
 +                              pos, regs, stop);
 +  return result;
 +}
 +
 +
 +/* This is a separate function so that we can force an alloca cleanup
 +   afterwards.  */
 +static ptrdiff_t
 +re_match_2_internal (struct re_pattern_buffer *bufp, re_char *string1,
 +                   size_t size1, re_char *string2, size_t size2,
 +                   ptrdiff_t pos, struct re_registers *regs, ptrdiff_t stop)
 +{
 +  /* General temporaries.  */
 +  int mcnt;
 +  size_t reg;
 +
 +  /* Just past the end of the corresponding string.  */
 +  re_char *end1, *end2;
 +
 +  /* Pointers into string1 and string2, just past the last characters in
 +     each to consider matching.  */
 +  re_char *end_match_1, *end_match_2;
 +
 +  /* Where we are in the data, and the end of the current string.  */
 +  re_char *d, *dend;
 +
 +  /* Used sometimes to remember where we were before starting matching
 +     an operator so that we can go back in case of failure.  This "atomic"
 +     behavior of matching opcodes is indispensable to the correctness
 +     of the on_failure_keep_string_jump optimization.  */
 +  re_char *dfail;
 +
 +  /* Where we are in the pattern, and the end of the pattern.  */
 +  re_char *p = bufp->buffer;
 +  re_char *pend = p + bufp->used;
 +
 +  /* We use this to map every character in the string.        */
 +  Lisp_Object translate = bufp->translate;
 +
 +  /* True if BUFP is setup from a multibyte regex.  */
 +  bool multibyte = RE_MULTIBYTE_P (bufp);
 +
 +  /* True if STRING1/STRING2 are multibyte.  */
 +  bool target_multibyte = RE_TARGET_MULTIBYTE_P (bufp);
 +
 +  /* Failure point stack.  Each place that can handle a failure further
 +     down the line pushes a failure point on this stack.  It consists of
 +     regstart, and regend for all registers corresponding to
 +     the subexpressions we're currently inside, plus the number of such
 +     registers, and, finally, two char *'s.  The first char * is where
 +     to resume scanning the pattern; the second one is where to resume
 +     scanning the strings.  */
 +  fail_stack_type fail_stack;
 +#ifdef DEBUG_COMPILES_ARGUMENTS
 +  unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
 +#endif
 +
 +  /* We fill all the registers internally, independent of what we
 +     return, for use in backreferences.  The number here includes
 +     an element for register zero.  */
 +  size_t num_regs = bufp->re_nsub + 1;
 +
 +  /* Information on the contents of registers. These are pointers into
 +     the input strings; they record just what was matched (on this
 +     attempt) by a subexpression part of the pattern, that is, the
 +     regnum-th regstart pointer points to where in the pattern we began
 +     matching and the regnum-th regend points to right after where we
 +     stopped matching the regnum-th subexpression.  (The zeroth register
 +     keeps track of what the whole pattern matches.)  */
 +  re_char **regstart UNINIT, **regend UNINIT;
 +
 +  /* The following record the register info as found in the above
 +     variables when we find a match better than any we've seen before.
 +     This happens as we backtrack through the failure points, which in
 +     turn happens only if we have not yet matched the entire string. */
 +  unsigned best_regs_set = false;
 +  re_char **best_regstart UNINIT, **best_regend UNINIT;
 +
 +  /* Logically, this is 'best_regend[0]'.  But we don't want to have to
 +     allocate space for that if we're not allocating space for anything
 +     else (see below).  Also, we never need info about register 0 for
 +     any of the other register vectors, and it seems rather a kludge to
 +     treat 'best_regend' differently than the rest.  So we keep track of
 +     the end of the best match so far in a separate variable.  We
 +     initialize this to NULL so that when we backtrack the first time
 +     and need to test it, it's not garbage.  */
 +  re_char *match_end = NULL;
 +
 +#ifdef DEBUG_COMPILES_ARGUMENTS
 +  /* Counts the total number of registers pushed.  */
 +  unsigned num_regs_pushed = 0;
 +#endif
 +
 +  DEBUG_PRINT ("\n\nEntering re_match_2.\n");
 +
 +  REGEX_USE_SAFE_ALLOCA;
 +
 +  INIT_FAIL_STACK ();
 +
 +  /* Do not bother to initialize all the register variables if there are
 +     no groups in the pattern, as it takes a fair amount of time.  If
 +     there are groups, we include space for register 0 (the whole
 +     pattern), even though we never use it, since it simplifies the
 +     array indexing.  We should fix this.  */
 +  if (bufp->re_nsub)
 +    {
 +      regstart = SAFE_ALLOCA (num_regs * 4 * sizeof *regstart);
 +      regend = regstart + num_regs;
 +      best_regstart = regend + num_regs;
 +      best_regend = best_regstart + num_regs;
 +    }
 +
 +  /* The starting position is bogus.  */
 +  if (pos < 0 || pos > size1 + size2)
 +    {
 +      SAFE_FREE ();
 +      return -1;
 +    }
 +
 +  /* Initialize subexpression text positions to -1 to mark ones that no
 +     start_memory/stop_memory has been seen for. Also initialize the
 +     register information struct.  */
 +  for (reg = 1; reg < num_regs; reg++)
 +    regstart[reg] = regend[reg] = NULL;
 +
 +  /* We move 'string1' into 'string2' if the latter's empty -- but not if
 +     'string1' is null.  */
 +  if (size2 == 0 && string1 != NULL)
 +    {
 +      string2 = string1;
 +      size2 = size1;
 +      string1 = 0;
 +      size1 = 0;
 +    }
 +  end1 = string1 + size1;
 +  end2 = string2 + size2;
 +
 +  /* P scans through the pattern as D scans through the data.
 +     DEND is the end of the input string that D points within.
 +     Advance D into the following input string whenever necessary, but
 +     this happens before fetching; therefore, at the beginning of the
 +     loop, D can be pointing at the end of a string, but it cannot
 +     equal STRING2.  */
 +  if (pos >= size1)
 +    {
 +      /* Only match within string2.  */
 +      d = string2 + pos - size1;
 +      dend = end_match_2 = string2 + stop - size1;
 +      end_match_1 = end1;     /* Just to give it a value.  */
 +    }
 +  else
 +    {
 +      if (stop < size1)
 +      {
 +        /* Only match within string1.  */
 +        end_match_1 = string1 + stop;
 +        /* BEWARE!
 +           When we reach end_match_1, PREFETCH normally switches to string2.
 +           But in the present case, this means that just doing a PREFETCH
 +           makes us jump from 'stop' to 'gap' within the string.
 +           What we really want here is for the search to stop as
 +           soon as we hit end_match_1.  That's why we set end_match_2
 +           to end_match_1 (since PREFETCH fails as soon as we hit
 +           end_match_2).  */
 +        end_match_2 = end_match_1;
 +      }
 +      else
 +      { /* It's important to use this code when STOP == SIZE so that
 +           moving D from end1 to string2 will not prevent the D == DEND
 +           check from catching the end of string.  */
 +        end_match_1 = end1;
 +        end_match_2 = string2 + stop - size1;
 +      }
 +      d = string1 + pos;
 +      dend = end_match_1;
 +    }
 +
 +  DEBUG_PRINT ("The compiled pattern is: ");
 +  DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
 +  DEBUG_PRINT ("The string to match is: \"");
 +  DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
 +  DEBUG_PRINT ("\"\n");
 +
 +  /* This loops over pattern commands.  It exits by returning from the
 +     function if the match is complete, or it drops through if the match
 +     fails at this starting point in the input data.  */
 +  for (;;)
 +    {
 +      DEBUG_PRINT ("\n%p: ", p);
 +
 +      if (p == pend)
 +      {
 +        /* End of pattern means we might have succeeded.  */
 +        DEBUG_PRINT ("end of pattern ... ");
 +
 +        /* If we haven't matched the entire string, and we want the
 +           longest match, try backtracking.  */
 +        if (d != end_match_2)
 +          {
 +            /* True if this match is the best seen so far.  */
 +            bool best_match_p;
 +
 +            {
 +              /* True if this match ends in the same string (string1
 +                 or string2) as the best previous match.  */
 +              bool same_str_p = (FIRST_STRING_P (match_end)
 +                                 == FIRST_STRING_P (d));
 +
 +              /* AIX compiler got confused when this was combined
 +                 with the previous declaration.  */
 +              if (same_str_p)
 +                best_match_p = d > match_end;
 +              else
 +                best_match_p = !FIRST_STRING_P (d);
 +            }
 +
 +            DEBUG_PRINT ("backtracking.\n");
 +
 +            if (!FAIL_STACK_EMPTY ())
 +              { /* More failure points to try.  */
 +
 +                /* If exceeds best match so far, save it.  */
 +                if (!best_regs_set || best_match_p)
 +                  {
 +                    best_regs_set = true;
 +                    match_end = d;
 +
 +                    DEBUG_PRINT ("\nSAVING match as best so far.\n");
 +
 +                    for (reg = 1; reg < num_regs; reg++)
 +                      {
 +                        best_regstart[reg] = regstart[reg];
 +                        best_regend[reg] = regend[reg];
 +                      }
 +                  }
 +                goto fail;
 +              }
 +
 +            /* If no failure points, don't restore garbage.  And if
 +               last match is real best match, don't restore second
 +               best one. */
 +            else if (best_regs_set && !best_match_p)
 +              {
 +              restore_best_regs:
 +                /* Restore best match.  It may happen that 'dend ==
 +                   end_match_1' while the restored d is in string2.
 +                   For example, the pattern 'x.*y.*z' against the
 +                   strings 'x-' and 'y-z-', if the two strings are
 +                   not consecutive in memory.  */
 +                DEBUG_PRINT ("Restoring best registers.\n");
 +
 +                d = match_end;
 +                dend = ((d >= string1 && d <= end1)
 +                         ? end_match_1 : end_match_2);
 +
 +                for (reg = 1; reg < num_regs; reg++)
 +                  {
 +                    regstart[reg] = best_regstart[reg];
 +                    regend[reg] = best_regend[reg];
 +                  }
 +              }
 +          } /* d != end_match_2 */
 +
 +      succeed_label:
 +        DEBUG_PRINT ("Accepting match.\n");
 +
 +        /* If caller wants register contents data back, do it.  */
 +        if (regs)
 +          {
 +            /* Have the register data arrays been allocated?  */
 +            if (bufp->regs_allocated == REGS_UNALLOCATED)
 +              { /* No.  So allocate them with malloc.  We need one
 +                   extra element beyond 'num_regs' for the '-1' marker
 +                   GNU code uses.  */
 +                regs->num_regs = max (RE_NREGS, num_regs + 1);
 +                regs->start = TALLOC (regs->num_regs, ptrdiff_t);
 +                regs->end = TALLOC (regs->num_regs, ptrdiff_t);
 +                bufp->regs_allocated = REGS_REALLOCATE;
 +              }
 +            else if (bufp->regs_allocated == REGS_REALLOCATE)
 +              { /* Yes.  If we need more elements than were already
 +                   allocated, reallocate them.  If we need fewer, just
 +                   leave it alone.  */
 +                if (regs->num_regs < num_regs + 1)
 +                  {
 +                    regs->num_regs = num_regs + 1;
 +                    RETALLOC (regs->start, regs->num_regs, ptrdiff_t);
 +                    RETALLOC (regs->end, regs->num_regs, ptrdiff_t);
 +                  }
 +              }
 +            else
 +              eassert (bufp->regs_allocated == REGS_FIXED);
 +
 +            /* Convert the pointer data in 'regstart' and 'regend' to
 +               indices.  Register zero has to be set differently,
 +               since we haven't kept track of any info for it.  */
 +            if (regs->num_regs > 0)
 +              {
 +                regs->start[0] = pos;
 +                regs->end[0] = POINTER_TO_OFFSET (d);
 +              }
 +
 +            /* Go through the first 'min (num_regs, regs->num_regs)'
 +               registers, since that is all we initialized.  */
 +            for (reg = 1; reg < min (num_regs, regs->num_regs); reg++)
 +              {
 +                if (REG_UNSET (regstart[reg]) || REG_UNSET (regend[reg]))
 +                  regs->start[reg] = regs->end[reg] = -1;
 +                else
 +                  {
 +                    regs->start[reg] = POINTER_TO_OFFSET (regstart[reg]);
 +                    regs->end[reg] = POINTER_TO_OFFSET (regend[reg]);
 +                  }
 +              }
 +
 +            /* If the regs structure we return has more elements than
 +               were in the pattern, set the extra elements to -1.  If
 +               we (re)allocated the registers, this is the case,
 +               because we always allocate enough to have at least one
 +               -1 at the end.  */
 +            for (reg = num_regs; reg < regs->num_regs; reg++)
 +              regs->start[reg] = regs->end[reg] = -1;
 +          }
 +
 +        DEBUG_PRINT ("%u failure points pushed, %u popped (%u remain).\n",
 +                     nfailure_points_pushed, nfailure_points_popped,
 +                     nfailure_points_pushed - nfailure_points_popped);
 +        DEBUG_PRINT ("%u registers pushed.\n", num_regs_pushed);
 +
 +        ptrdiff_t dcnt = POINTER_TO_OFFSET (d) - pos;
 +
 +        DEBUG_PRINT ("Returning %td from re_match_2.\n", dcnt);
 +
 +        SAFE_FREE ();
 +        return dcnt;
 +      }
 +
 +      /* Otherwise match next pattern command.  */
 +      switch (*p++)
 +      {
 +      /* Ignore these.  Used to ignore the n of succeed_n's which
 +         currently have n == 0.  */
 +      case no_op:
 +        DEBUG_PRINT ("EXECUTING no_op.\n");
 +        break;
 +
 +      case succeed:
 +        DEBUG_PRINT ("EXECUTING succeed.\n");
 +        goto succeed_label;
 +
 +      /* Match the next n pattern characters exactly.  The following
 +         byte in the pattern defines n, and the n bytes after that
 +         are the characters to match.  */
 +      case exactn:
 +        mcnt = *p++;
 +        DEBUG_PRINT ("EXECUTING exactn %d.\n", mcnt);
 +
 +        /* Remember the start point to rollback upon failure.  */
 +        dfail = d;
 +
 +        /* The cost of testing 'translate' is comparatively small.  */
 +        if (target_multibyte)
 +          do
 +            {
 +              int pat_charlen, buf_charlen;
 +              int pat_ch, buf_ch;
 +
 +              PREFETCH ();
 +              if (multibyte)
 +                pat_ch = STRING_CHAR_AND_LENGTH (p, pat_charlen);
 +              else
 +                {
 +                  pat_ch = RE_CHAR_TO_MULTIBYTE (*p);
 +                  pat_charlen = 1;
 +                }
 +              buf_ch = STRING_CHAR_AND_LENGTH (d, buf_charlen);
 +
 +              if (TRANSLATE (buf_ch) != pat_ch)
 +                {
 +                  d = dfail;
 +                  goto fail;
 +                }
 +
 +              p += pat_charlen;
 +              d += buf_charlen;
 +              mcnt -= pat_charlen;
 +            }
 +          while (mcnt > 0);
 +        else
 +          do
 +            {
 +              int pat_charlen;
 +              int pat_ch, buf_ch;
 +
 +              PREFETCH ();
 +              if (multibyte)
 +                {
 +                  pat_ch = STRING_CHAR_AND_LENGTH (p, pat_charlen);
 +                  pat_ch = RE_CHAR_TO_UNIBYTE (pat_ch);
 +                }
 +              else
 +                {
 +                  pat_ch = *p;
 +                  pat_charlen = 1;
 +                }
 +              buf_ch = RE_CHAR_TO_MULTIBYTE (*d);
 +              if (! CHAR_BYTE8_P (buf_ch))
 +                {
 +                  buf_ch = TRANSLATE (buf_ch);
 +                  buf_ch = RE_CHAR_TO_UNIBYTE (buf_ch);
 +                  if (buf_ch < 0)
 +                    buf_ch = *d;
 +                }
 +              else
 +                buf_ch = *d;
 +              if (buf_ch != pat_ch)
 +                {
 +                  d = dfail;
 +                  goto fail;
 +                }
 +              p += pat_charlen;
 +              d++;
 +            }
 +          while (--mcnt);
 +
 +        break;
 +
 +
 +      /* Match any character except newline.  */
 +      case anychar:
 +        {
 +          int buf_charlen;
 +          int buf_ch;
 +
 +          DEBUG_PRINT ("EXECUTING anychar.\n");
 +
 +          PREFETCH ();
 +          buf_ch = RE_STRING_CHAR_AND_LENGTH (d, buf_charlen,
 +                                              target_multibyte);
 +          buf_ch = TRANSLATE (buf_ch);
 +          if (buf_ch == '\n')
 +            goto fail;
 +
 +          DEBUG_PRINT ("  Matched \"%d\".\n", *d);
 +          d += buf_charlen;
 +        }
 +        break;
 +
 +
 +      case charset:
 +      case charset_not:
 +        {
 +          register unsigned int c, corig;
 +          int len;
 +
 +          /* Whether matching against a unibyte character.  */
 +          bool unibyte_char = false;
 +
 +          DEBUG_PRINT ("EXECUTING charset%s.\n",
 +                       (re_opcode_t) *(p - 1) == charset_not ? "_not" : "");
 +
 +          PREFETCH ();
 +          corig = c = RE_STRING_CHAR_AND_LENGTH (d, len, target_multibyte);
 +          if (target_multibyte)
 +            {
 +              int c1;
 +
 +              c = TRANSLATE (c);
 +              c1 = RE_CHAR_TO_UNIBYTE (c);
 +              if (c1 >= 0)
 +                {
 +                  unibyte_char = true;
 +                  c = c1;
 +                }
 +            }
 +          else
 +            {
 +              int c1 = RE_CHAR_TO_MULTIBYTE (c);
 +
 +              if (! CHAR_BYTE8_P (c1))
 +                {
 +                  c1 = TRANSLATE (c1);
 +                  c1 = RE_CHAR_TO_UNIBYTE (c1);
 +                  if (c1 >= 0)
 +                    {
 +                      unibyte_char = true;
 +                      c = c1;
 +                    }
 +                }
 +              else
 +                unibyte_char = true;
 +            }
 +
 +          p -= 1;
 +          if (!execute_charset (&p, c, corig, unibyte_char))
 +            goto fail;
 +
 +          d += len;
 +        }
 +        break;
 +
 +
 +      /* The beginning of a group is represented by start_memory.
 +         The argument is the register number.  The text
 +         matched within the group is recorded (in the internal
 +         registers data structure) under the register number.  */
 +      case start_memory:
 +        DEBUG_PRINT ("EXECUTING start_memory %d:\n", *p);
 +
 +        /* In case we need to undo this operation (via backtracking).  */
 +        PUSH_FAILURE_REG (*p);
 +
 +        regstart[*p] = d;
 +        regend[*p] = NULL;    /* probably unnecessary.  -sm  */
 +        DEBUG_PRINT ("  regstart: %td\n", POINTER_TO_OFFSET (regstart[*p]));
 +
 +        /* Move past the register number and inner group count.  */
 +        p += 1;
 +        break;
 +
 +
 +      /* The stop_memory opcode represents the end of a group.  Its
 +         argument is the same as start_memory's: the register number.  */
 +      case stop_memory:
 +        DEBUG_PRINT ("EXECUTING stop_memory %d:\n", *p);
 +
 +        eassert (!REG_UNSET (regstart[*p]));
 +        /* Strictly speaking, there should be code such as:
 +
 +              eassert (REG_UNSET (regend[*p]));
 +              PUSH_FAILURE_REGSTOP ((unsigned int)*p);
 +
 +           But the only info to be pushed is regend[*p] and it is known to
 +           be UNSET, so there really isn't anything to push.
 +           Not pushing anything, on the other hand deprives us from the
 +           guarantee that regend[*p] is UNSET since undoing this operation
 +           will not reset its value properly.  This is not important since
 +           the value will only be read on the next start_memory or at
 +           the very end and both events can only happen if this stop_memory
 +           is *not* undone.  */
 +
 +        regend[*p] = d;
 +        DEBUG_PRINT ("      regend: %td\n", POINTER_TO_OFFSET (regend[*p]));
 +
 +        /* Move past the register number and the inner group count.  */
 +        p += 1;
 +        break;
 +
 +
 +      /* \<digit> has been turned into a 'duplicate' command which is
 +         followed by the numeric value of <digit> as the register number.  */
 +      case duplicate:
 +        {
 +          re_char *d2, *dend2;
 +          int regno = *p++;   /* Get which register to match against.  */
 +          DEBUG_PRINT ("EXECUTING duplicate %d.\n", regno);
 +
 +          /* Can't back reference a group which we've never matched.  */
 +          if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
 +            goto fail;
 +
 +          /* Where in input to try to start matching.  */
 +          d2 = regstart[regno];
 +
 +          /* Remember the start point to rollback upon failure.  */
 +          dfail = d;
 +
 +          /* Where to stop matching; if both the place to start and
 +             the place to stop matching are in the same string, then
 +             set to the place to stop, otherwise, for now have to use
 +             the end of the first string.  */
 +
 +          dend2 = ((FIRST_STRING_P (regstart[regno])
 +                    == FIRST_STRING_P (regend[regno]))
 +                   ? regend[regno] : end_match_1);
 +          for (;;)
 +            {
 +              ptrdiff_t dcnt;
 +
 +              /* If necessary, advance to next segment in register
 +                 contents.  */
 +              while (d2 == dend2)
 +                {
 +                  if (dend2 == end_match_2) break;
 +                  if (dend2 == regend[regno]) break;
 +
 +                  /* End of string1 => advance to string2. */
 +                  d2 = string2;
 +                  dend2 = regend[regno];
 +                }
 +              /* At end of register contents => success */
 +              if (d2 == dend2) break;
 +
 +              /* If necessary, advance to next segment in data.  */
 +              PREFETCH ();
 +
 +              /* How many characters left in this segment to match.  */
 +              dcnt = dend - d;
 +
 +              /* Want how many consecutive characters we can match in
 +                 one shot, so, if necessary, adjust the count.  */
 +              if (dcnt > dend2 - d2)
 +                dcnt = dend2 - d2;
 +
 +              /* Compare that many; failure if mismatch, else move
 +                 past them.  */
 +              if (!NILP (translate)
 +                  ? bcmp_translate (d, d2, dcnt, translate, target_multibyte)
 +                  : memcmp (d, d2, dcnt))
 +                {
 +                  d = dfail;
 +                  goto fail;
 +                }
 +              d += dcnt, d2 += dcnt;
 +            }
 +        }
 +        break;
 +
 +
 +      /* begline matches the empty string at the beginning of the string,
 +         and after newlines.  */
 +      case begline:
 +        DEBUG_PRINT ("EXECUTING begline.\n");
 +
 +        if (AT_STRINGS_BEG (d))
 +          break;
 +        else
 +          {
 +            unsigned c;
 +            GET_CHAR_BEFORE_2 (c, d, string1, end1, string2, end2);
 +            if (c == '\n')
 +              break;
 +          }
 +        goto fail;
 +
 +
 +      /* endline is the dual of begline.  */
 +      case endline:
 +        DEBUG_PRINT ("EXECUTING endline.\n");
 +
 +        if (AT_STRINGS_END (d))
 +          break;
 +        PREFETCH_NOLIMIT ();
 +        if (*d == '\n')
 +          break;
 +        goto fail;
 +
 +
 +      /* Match at the very beginning of the data.  */
 +      case begbuf:
 +        DEBUG_PRINT ("EXECUTING begbuf.\n");
 +        if (AT_STRINGS_BEG (d))
 +          break;
 +        goto fail;
 +
 +
 +      /* Match at the very end of the data.  */
 +      case endbuf:
 +        DEBUG_PRINT ("EXECUTING endbuf.\n");
 +        if (AT_STRINGS_END (d))
 +          break;
 +        goto fail;
 +
 +
 +      /* on_failure_keep_string_jump is used to optimize '.*\n'.  It
 +         pushes NULL as the value for the string on the stack.  Then
 +         'POP_FAILURE_POINT' will keep the current value for the
 +         string, instead of restoring it.  To see why, consider
 +         matching 'foo\nbar' against '.*\n'.  The .* matches the foo;
 +         then the . fails against the \n.  But the next thing we want
 +         to do is match the \n against the \n; if we restored the
 +         string value, we would be back at the foo.
 +
 +         Because this is used only in specific cases, we don't need to
 +         check all the things that 'on_failure_jump' does, to make
 +         sure the right things get saved on the stack.  Hence we don't
 +         share its code.  The only reason to push anything on the
 +         stack at all is that otherwise we would have to change
 +         'anychar's code to do something besides goto fail in this
 +         case; that seems worse than this.  */
 +      case on_failure_keep_string_jump:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        DEBUG_PRINT ("EXECUTING on_failure_keep_string_jump %d (to %p):\n",
 +                     mcnt, p + mcnt);
 +
 +        PUSH_FAILURE_POINT (p - 3, NULL);
 +        break;
 +
 +        /* A nasty loop is introduced by the non-greedy *? and +?.
 +           With such loops, the stack only ever contains one failure point
 +           at a time, so that a plain on_failure_jump_loop kind of
 +           cycle detection cannot work.  Worse yet, such a detection
 +           can not only fail to detect a cycle, but it can also wrongly
 +           detect a cycle (between different instantiations of the same
 +           loop).
 +           So the method used for those nasty loops is a little different:
 +           We use a special cycle-detection-stack-frame which is pushed
 +           when the on_failure_jump_nastyloop failure-point is *popped*.
 +           This special frame thus marks the beginning of one iteration
 +           through the loop and we can hence easily check right here
 +           whether something matched between the beginning and the end of
 +           the loop.  */
 +      case on_failure_jump_nastyloop:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        DEBUG_PRINT ("EXECUTING on_failure_jump_nastyloop %d (to %p):\n",
 +                     mcnt, p + mcnt);
 +
 +        eassert ((re_opcode_t)p[-4] == no_op);
 +        {
 +          int cycle = 0;
 +          CHECK_INFINITE_LOOP (p - 4, d);
 +          if (!cycle)
 +            /* If there's a cycle, just continue without pushing
 +               this failure point.  The failure point is the "try again"
 +               option, which shouldn't be tried.
 +               We want (x?)*?y\1z to match both xxyz and xxyxz.  */
 +            PUSH_FAILURE_POINT (p - 3, d);
 +        }
 +        break;
 +
 +        /* Simple loop detecting on_failure_jump:  just check on the
 +           failure stack if the same spot was already hit earlier.  */
 +      case on_failure_jump_loop:
 +      on_failure:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        DEBUG_PRINT ("EXECUTING on_failure_jump_loop %d (to %p):\n",
 +                     mcnt, p + mcnt);
 +        {
 +          int cycle = 0;
 +          CHECK_INFINITE_LOOP (p - 3, d);
 +          if (cycle)
 +            /* If there's a cycle, get out of the loop, as if the matching
 +               had failed.  We used to just 'goto fail' here, but that was
 +               aborting the search a bit too early: we want to keep the
 +               empty-loop-match and keep matching after the loop.
 +               We want (x?)*y\1z to match both xxyz and xxyxz.  */
 +            p += mcnt;
 +          else
 +            PUSH_FAILURE_POINT (p - 3, d);
 +        }
 +        break;
 +
 +
 +      /* Uses of on_failure_jump:
 +
 +         Each alternative starts with an on_failure_jump that points
 +         to the beginning of the next alternative.  Each alternative
 +         except the last ends with a jump that in effect jumps past
 +         the rest of the alternatives.  (They really jump to the
 +         ending jump of the following alternative, because tensioning
 +         these jumps is a hassle.)
 +
 +         Repeats start with an on_failure_jump that points past both
 +         the repetition text and either the following jump or
 +         pop_failure_jump back to this on_failure_jump.  */
 +      case on_failure_jump:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        DEBUG_PRINT ("EXECUTING on_failure_jump %d (to %p):\n",
 +                     mcnt, p + mcnt);
 +
 +        PUSH_FAILURE_POINT (p -3, d);
 +        break;
 +
 +      /* This operation is used for greedy *.
 +         Compare the beginning of the repeat with what in the
 +         pattern follows its end. If we can establish that there
 +         is nothing that they would both match, i.e., that we
 +         would have to backtrack because of (as in, e.g., 'a*a')
 +         then we can use a non-backtracking loop based on
 +         on_failure_keep_string_jump instead of on_failure_jump.  */
 +      case on_failure_jump_smart:
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +        DEBUG_PRINT ("EXECUTING on_failure_jump_smart %d (to %p).\n",
 +                     mcnt, p + mcnt);
 +        {
 +          re_char *p1 = p; /* Next operation.  */
 +          /* Discard 'const', making re_search non-reentrant.  */
 +          unsigned char *p2 = (unsigned char *) p + mcnt; /* Jump dest.  */
 +          unsigned char *p3 = (unsigned char *) p - 3; /* opcode location.  */
 +
 +          p -= 3;             /* Reset so that we will re-execute the
 +                                 instruction once it's been changed. */
 +
 +          EXTRACT_NUMBER (mcnt, p2 - 2);
 +
 +          /* Ensure this is indeed the trivial kind of loop
 +             we are expecting.  */
 +          eassert (skip_one_char (p1) == p2 - 3);
 +          eassert ((re_opcode_t) p2[-3] == jump && p2 + mcnt == p);
 +          DEBUG_STATEMENT (regex_emacs_debug += 2);
 +          if (mutually_exclusive_p (bufp, p1, p2))
 +            {
 +              /* Use a fast 'on_failure_keep_string_jump' loop.  */
 +              DEBUG_PRINT ("  smart exclusive => fast loop.\n");
 +              *p3 = (unsigned char) on_failure_keep_string_jump;
 +              STORE_NUMBER (p2 - 2, mcnt + 3);
 +            }
 +          else
 +            {
 +              /* Default to a safe 'on_failure_jump' loop.  */
 +              DEBUG_PRINT ("  smart default => slow loop.\n");
 +              *p3 = (unsigned char) on_failure_jump;
 +            }
 +          DEBUG_STATEMENT (regex_emacs_debug -= 2);
 +        }
 +        break;
 +
 +      /* Unconditionally jump (without popping any failure points).  */
 +      case jump:
 +      unconditional_jump:
 +        maybe_quit ();
 +        EXTRACT_NUMBER_AND_INCR (mcnt, p);    /* Get the amount to jump.  */
 +        DEBUG_PRINT ("EXECUTING jump %d ", mcnt);
 +        p += mcnt;                            /* Do the jump.  */
 +        DEBUG_PRINT ("(to %p).\n", p);
 +        break;
 +
 +
 +      /* Have to succeed matching what follows at least n times.
 +         After that, handle like 'on_failure_jump'.  */
 +      case succeed_n:
 +        /* Signedness doesn't matter since we only compare MCNT to 0.  */
 +        EXTRACT_NUMBER (mcnt, p + 2);
 +        DEBUG_PRINT ("EXECUTING succeed_n %d.\n", mcnt);
 +
 +        /* Originally, mcnt is how many times we HAVE to succeed.  */
 +        if (mcnt != 0)
 +          {
 +            /* Discard 'const', making re_search non-reentrant.  */
 +            unsigned char *p2 = (unsigned char *) p + 2; /* counter loc.  */
 +            mcnt--;
 +            p += 4;
 +            PUSH_NUMBER (p2, mcnt);
 +          }
 +        else
 +          /* The two bytes encoding mcnt == 0 are two no_op opcodes.  */
 +          goto on_failure;
 +        break;
 +
 +      case jump_n:
 +        /* Signedness doesn't matter since we only compare MCNT to 0.  */
 +        EXTRACT_NUMBER (mcnt, p + 2);
 +        DEBUG_PRINT ("EXECUTING jump_n %d.\n", mcnt);
 +
 +        /* Originally, this is how many times we CAN jump.  */
 +        if (mcnt != 0)
 +          {
 +            /* Discard 'const', making re_search non-reentrant.  */
 +            unsigned char *p2 = (unsigned char *) p + 2; /* counter loc.  */
 +            mcnt--;
 +            PUSH_NUMBER (p2, mcnt);
 +            goto unconditional_jump;
 +          }
 +        /* If don't have to jump any more, skip over the rest of command.  */
 +        else
 +          p += 4;
 +        break;
 +
 +      case set_number_at:
 +        {
 +          unsigned char *p2;  /* Location of the counter.  */
 +          DEBUG_PRINT ("EXECUTING set_number_at.\n");
 +
 +          EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +          /* Discard 'const', making re_search non-reentrant.  */
 +          p2 = (unsigned char *) p + mcnt;
 +          /* Signedness doesn't matter since we only copy MCNT's bits.  */
 +          EXTRACT_NUMBER_AND_INCR (mcnt, p);
 +          DEBUG_PRINT ("  Setting %p to %d.\n", p2, mcnt);
 +          PUSH_NUMBER (p2, mcnt);
 +          break;
 +        }
 +
 +      case wordbound:
 +      case notwordbound:
 +        {
 +          bool not = (re_opcode_t) *(p - 1) == notwordbound;
 +          DEBUG_PRINT ("EXECUTING %swordbound.\n", not ? "not" : "");
 +
 +          /* We SUCCEED (or FAIL) in one of the following cases: */
 +
 +          /* Case 1: D is at the beginning or the end of string.  */
 +          if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
 +            not = !not;
 +          else
 +            {
 +              /* C1 is the character before D, S1 is the syntax of C1, C2
 +                 is the character at D, and S2 is the syntax of C2.  */
 +              int c1, c2;
 +              int s1, s2;
 +              int dummy;
 +              ptrdiff_t offset = PTR_TO_OFFSET (d - 1);
 +              ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +              UPDATE_SYNTAX_TABLE (charpos);
 +              GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
 +              s1 = SYNTAX (c1);
 +              UPDATE_SYNTAX_TABLE_FORWARD (charpos + 1);
 +              PREFETCH_NOLIMIT ();
 +              GET_CHAR_AFTER (c2, d, dummy);
 +              s2 = SYNTAX (c2);
 +
 +              if (/* Case 2: Only one of S1 and S2 is Sword.  */
 +                  ((s1 == Sword) != (s2 == Sword))
 +                  /* Case 3: Both of S1 and S2 are Sword, and macro
 +                     WORD_BOUNDARY_P (C1, C2) returns nonzero.  */
 +                  || ((s1 == Sword) && WORD_BOUNDARY_P (c1, c2)))
 +                not = !not;
 +            }
 +          if (not)
 +            break;
 +          else
 +            goto fail;
 +        }
 +
 +      case wordbeg:
 +        DEBUG_PRINT ("EXECUTING wordbeg.\n");
 +
 +        /* We FAIL in one of the following cases: */
 +
 +        /* Case 1: D is at the end of string.  */
 +        if (AT_STRINGS_END (d))
 +          goto fail;
 +        else
 +          {
 +            /* C1 is the character before D, S1 is the syntax of C1, C2
 +               is the character at D, and S2 is the syntax of C2.  */
 +            int c1, c2;
 +            int s1, s2;
 +            int dummy;
 +            ptrdiff_t offset = PTR_TO_OFFSET (d);
 +            ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +            UPDATE_SYNTAX_TABLE (charpos);
 +            PREFETCH ();
 +            GET_CHAR_AFTER (c2, d, dummy);
 +            s2 = SYNTAX (c2);
 +
 +            /* Case 2: S2 is not Sword. */
 +            if (s2 != Sword)
 +              goto fail;
 +
 +            /* Case 3: D is not at the beginning of string ... */
 +            if (!AT_STRINGS_BEG (d))
 +              {
 +                GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
 +                UPDATE_SYNTAX_TABLE_BACKWARD (charpos - 1);
 +                s1 = SYNTAX (c1);
 +
 +                /* ... and S1 is Sword, and WORD_BOUNDARY_P (C1, C2)
 +                   returns 0.  */
 +                if ((s1 == Sword) && !WORD_BOUNDARY_P (c1, c2))
 +                  goto fail;
 +              }
 +          }
 +        break;
 +
 +      case wordend:
 +        DEBUG_PRINT ("EXECUTING wordend.\n");
 +
 +        /* We FAIL in one of the following cases: */
 +
 +        /* Case 1: D is at the beginning of string.  */
 +        if (AT_STRINGS_BEG (d))
 +          goto fail;
 +        else
 +          {
 +            /* C1 is the character before D, S1 is the syntax of C1, C2
 +               is the character at D, and S2 is the syntax of C2.  */
 +            int c1, c2;
 +            int s1, s2;
 +            int dummy;
 +            ptrdiff_t offset = PTR_TO_OFFSET (d) - 1;
 +            ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +            UPDATE_SYNTAX_TABLE (charpos);
 +            GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
 +            s1 = SYNTAX (c1);
 +
 +            /* Case 2: S1 is not Sword.  */
 +            if (s1 != Sword)
 +              goto fail;
 +
 +            /* Case 3: D is not at the end of string ... */
 +            if (!AT_STRINGS_END (d))
 +              {
 +                PREFETCH_NOLIMIT ();
 +                GET_CHAR_AFTER (c2, d, dummy);
 +                UPDATE_SYNTAX_TABLE_FORWARD (charpos);
 +                s2 = SYNTAX (c2);
 +
 +                /* ... and S2 is Sword, and WORD_BOUNDARY_P (C1, C2)
 +                   returns 0.  */
 +                if ((s2 == Sword) && !WORD_BOUNDARY_P (c1, c2))
 +        goto fail;
 +              }
 +          }
 +        break;
 +
 +      case symbeg:
 +        DEBUG_PRINT ("EXECUTING symbeg.\n");
 +
 +        /* We FAIL in one of the following cases: */
 +
 +        /* Case 1: D is at the end of string.  */
 +        if (AT_STRINGS_END (d))
 +          goto fail;
 +        else
 +          {
 +            /* C1 is the character before D, S1 is the syntax of C1, C2
 +               is the character at D, and S2 is the syntax of C2.  */
 +            int c1, c2;
 +            int s1, s2;
 +            ptrdiff_t offset = PTR_TO_OFFSET (d);
 +            ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +            UPDATE_SYNTAX_TABLE (charpos);
 +            PREFETCH ();
 +            c2 = RE_STRING_CHAR (d, target_multibyte);
 +            s2 = SYNTAX (c2);
 +
 +            /* Case 2: S2 is neither Sword nor Ssymbol. */
 +            if (s2 != Sword && s2 != Ssymbol)
 +              goto fail;
 +
 +            /* Case 3: D is not at the beginning of string ... */
 +            if (!AT_STRINGS_BEG (d))
 +              {
 +                GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
 +                UPDATE_SYNTAX_TABLE_BACKWARD (charpos - 1);
 +                s1 = SYNTAX (c1);
 +
 +                /* ... and S1 is Sword or Ssymbol.  */
 +                if (s1 == Sword || s1 == Ssymbol)
 +                  goto fail;
 +              }
 +          }
 +        break;
 +
 +      case symend:
 +        DEBUG_PRINT ("EXECUTING symend.\n");
 +
 +        /* We FAIL in one of the following cases: */
 +
 +        /* Case 1: D is at the beginning of string.  */
 +        if (AT_STRINGS_BEG (d))
 +          goto fail;
 +        else
 +          {
 +            /* C1 is the character before D, S1 is the syntax of C1, C2
 +               is the character at D, and S2 is the syntax of C2.  */
 +            int c1, c2;
 +            int s1, s2;
 +            ptrdiff_t offset = PTR_TO_OFFSET (d) - 1;
 +            ptrdiff_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +            UPDATE_SYNTAX_TABLE (charpos);
 +            GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
 +            s1 = SYNTAX (c1);
 +
 +            /* Case 2: S1 is neither Ssymbol nor Sword.  */
 +            if (s1 != Sword && s1 != Ssymbol)
 +              goto fail;
 +
 +            /* Case 3: D is not at the end of string ... */
 +            if (!AT_STRINGS_END (d))
 +              {
 +                PREFETCH_NOLIMIT ();
 +                c2 = RE_STRING_CHAR (d, target_multibyte);
 +                UPDATE_SYNTAX_TABLE_FORWARD (charpos + 1);
 +                s2 = SYNTAX (c2);
 +
 +                /* ... and S2 is Sword or Ssymbol.  */
 +                if (s2 == Sword || s2 == Ssymbol)
 +                    goto fail;
 +              }
 +          }
 +        break;
 +
 +      case syntaxspec:
 +      case notsyntaxspec:
 +        {
 +          bool not = (re_opcode_t) *(p - 1) == notsyntaxspec;
 +          mcnt = *p++;
 +          DEBUG_PRINT ("EXECUTING %ssyntaxspec %d.\n", not ? "not" : "",
 +                       mcnt);
 +          PREFETCH ();
 +          {
 +            ptrdiff_t offset = PTR_TO_OFFSET (d);
 +            ptrdiff_t pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
 +            UPDATE_SYNTAX_TABLE (pos1);
 +          }
 +          {
 +            int len;
 +            int c;
 +
 +            GET_CHAR_AFTER (c, d, len);
 +            if ((SYNTAX (c) != (enum syntaxcode) mcnt) ^ not)
 +              goto fail;
 +            d += len;
 +          }
 +        }
 +        break;
 +
 +      case at_dot:
 +        DEBUG_PRINT ("EXECUTING at_dot.\n");
 +        if (PTR_BYTE_POS (d) != PT_BYTE)
 +          goto fail;
 +        break;
 +
 +      case categoryspec:
 +      case notcategoryspec:
 +        {
 +          bool not = (re_opcode_t) *(p - 1) == notcategoryspec;
 +          mcnt = *p++;
 +          DEBUG_PRINT ("EXECUTING %scategoryspec %d.\n",
 +                       not ? "not" : "", mcnt);
 +          PREFETCH ();
 +
 +          {
 +            int len;
 +            int c;
 +            GET_CHAR_AFTER (c, d, len);
 +            if ((!CHAR_HAS_CATEGORY (c, mcnt)) ^ not)
 +              goto fail;
 +            d += len;
 +          }
 +        }
 +        break;
 +
 +      default:
 +        abort ();
 +      }
 +      continue;  /* Successfully executed one pattern command; keep going.  */
 +
 +
 +    /* We goto here if a matching operation fails. */
 +    fail:
 +      maybe_quit ();
 +      if (!FAIL_STACK_EMPTY ())
 +      {
 +        re_char *str, *pat;
 +        /* A restart point is known.  Restore to that state.  */
 +        DEBUG_PRINT ("\nFAIL:\n");
 +        POP_FAILURE_POINT (str, pat);
 +        switch (*pat++)
 +          {
 +          case on_failure_keep_string_jump:
 +            eassert (str == NULL);
 +            goto continue_failure_jump;
 +
 +          case on_failure_jump_nastyloop:
 +            eassert ((re_opcode_t)pat[-2] == no_op);
 +            PUSH_FAILURE_POINT (pat - 2, str);
 +            FALLTHROUGH;
 +          case on_failure_jump_loop:
 +          case on_failure_jump:
 +          case succeed_n:
 +            d = str;
 +          continue_failure_jump:
 +            EXTRACT_NUMBER_AND_INCR (mcnt, pat);
 +            p = pat + mcnt;
 +            break;
 +
 +          case no_op:
 +            /* A special frame used for nastyloops. */
 +            goto fail;
 +
 +          default:
 +            abort ();
 +          }
 +
 +        eassert (p >= bufp->buffer && p <= pend);
 +
 +        if (d >= string1 && d <= end1)
 +          dend = end_match_1;
 +      }
 +      else
 +      break;   /* Matching at this starting point really fails.  */
 +    } /* for (;;) */
 +
 +  if (best_regs_set)
 +    goto restore_best_regs;
 +
 +  SAFE_FREE ();
 +
 +  return -1;                          /* Failure to match.  */
 +}
 +\f
 +/* Subroutine definitions for re_match_2.  */
 +
 +/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
 +   bytes; nonzero otherwise.  */
 +
 +static int
 +bcmp_translate (re_char *s1, re_char *s2, ptrdiff_t len,
 +              Lisp_Object translate, int target_multibyte)
 +{
 +  re_char *p1 = s1, *p2 = s2;
 +  re_char *p1_end = s1 + len;
 +  re_char *p2_end = s2 + len;
 +
 +  /* FIXME: Checking both p1 and p2 presumes that the two strings might have
 +     different lengths, but relying on a single LEN would break this. -sm  */
 +  while (p1 < p1_end && p2 < p2_end)
 +    {
 +      int p1_charlen, p2_charlen;
 +      int p1_ch, p2_ch;
 +
 +      GET_CHAR_AFTER (p1_ch, p1, p1_charlen);
 +      GET_CHAR_AFTER (p2_ch, p2, p2_charlen);
 +
 +      if (RE_TRANSLATE (translate, p1_ch)
 +        != RE_TRANSLATE (translate, p2_ch))
 +      return 1;
 +
 +      p1 += p1_charlen, p2 += p2_charlen;
 +    }
 +
 +  if (p1 != p1_end || p2 != p2_end)
 +    return 1;
 +
 +  return 0;
 +}
 +\f
 +/* Entry points for GNU code.  */
 +
 +/* re_compile_pattern is the GNU regular expression compiler: it
 +   compiles PATTERN (of length SIZE) and puts the result in BUFP.
 +   Returns 0 if the pattern was valid, otherwise an error string.
 +
 +   Assumes the 'allocated' (and perhaps 'buffer') and 'translate' fields
 +   are set in BUFP on entry.
 +
 +   We call regex_compile to do the actual compilation.  */
 +
 +const char *
 +re_compile_pattern (const char *pattern, size_t length,
 +                  bool posix_backtracking, const char *whitespace_regexp,
 +                  struct re_pattern_buffer *bufp)
 +{
 +  reg_errcode_t ret;
 +
 +  /* GNU code is written to assume at least RE_NREGS registers will be set
 +     (and at least one extra will be -1).  */
 +  bufp->regs_allocated = REGS_UNALLOCATED;
 +
 +  ret = regex_compile ((re_char *) pattern, length,
 +                     posix_backtracking,
 +                     whitespace_regexp,
 +                     bufp);
 +
 +  if (!ret)
 +    return NULL;
 +  return re_error_msgid[ret];
 +}

diff --cc src/scroll.c
Simple merge

diff --cc src/search.c
Simple merge

diff --cc src/sound.c
index 6f15f5dab6d07aac6b610d81c55c2e5332b07697,c1f869045f5d85ff73cefbdafe82a5c00263f69d..2b8715010e74315c37fcc9b3f664eaf7b4dc35d9
--- 1/src/sound.c
--- 2/src/sound.c
+++ b/src/sound.c
@@@ -1,9 -1,7 +1,9 @@@
  /* sound.c -- sound support.
  
- Copyright (C) 1998-1999, 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 1998-1999, 2001-2019 Free Software Foundation, Inc.
  
 +Author: Gerd Moellmann <gerd@gnu.org>
 +
  This file is part of GNU Emacs.
  
  GNU Emacs is free software: you can redistribute it and/or modify

diff --cc src/syntax.c
Simple merge

diff --cc src/syntax.h
Simple merge

diff --cc src/sysdep.c
Simple merge

diff --cc src/syssignal.h
Simple merge

diff --cc src/systhread.c
Simple merge

diff --cc src/systhread.h
Simple merge

diff --cc src/systime.h
Simple merge

diff --cc src/term.c
Simple merge

diff --cc src/termhooks.h
Simple merge

diff --cc src/terminal.c
Simple merge

diff --cc src/textprop.c
Simple merge

diff --cc src/thread.c
Simple merge

diff --cc src/thread.h
Simple merge

diff --cc src/tparam.h
Simple merge

diff --cc src/undo.c
Simple merge

diff --cc src/unexcw.c
Simple merge

diff --cc src/w16select.c
index a5f0757867122d416a4058a71eaff7b5fc4643b5,fb8161b61fad37725e89f8a4337a08a317e40c3c..b935b9f4f54f5fe7a865f3739ca06f829cb2ef4b
--- 1/src/w16select.c
--- 2/src/w16select.c
+++ b/src/w16select.c
@@@ -1,9 -1,7 +1,9 @@@
  /* 16-bit Windows Selection processing for emacs on MS-Windows
  
- Copyright (C) 1996-1997, 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 1996-1997, 2001-2019 Free Software Foundation, Inc.
  
 +Author: Dale P. Smith <dpsm@en.com>
 +
  This file is part of GNU Emacs.
  
  GNU Emacs is free software: you can redistribute it and/or modify

diff --cc src/w32.c
Simple merge

diff --cc src/w32.h
Simple merge

diff --cc src/w32common.h
Simple merge

diff --cc src/w32console.c
Simple merge

diff --cc src/w32fns.c
Simple merge

diff --cc src/w32font.c
Simple merge

diff --cc src/w32heap.c
Simple merge

diff --cc src/w32inevt.c
Simple merge

diff --cc src/w32menu.c
Simple merge

diff --cc src/w32notify.c
index 67385b80a8101f6dfb5c95b8e6b3f566000e8b32,e03650f0fd37f8013f511d47c926e0b7bb5bab1d..53787fd45db8021eaed01f8c77428b8aecc76e1d
--- 1/src/w32notify.c
--- 2/src/w32notify.c
+++ b/src/w32notify.c
@@@ -1,8 -1,5 +1,8 @@@
  /* Filesystem notifications support for GNU Emacs on the Microsoft Windows API.
 -   Copyright (C) 2012-2019 Free Software Foundation, Inc.
 +
- Copyright (C) 2012-2018 Free Software Foundation, Inc.
++Copyright (C) 2012-2019 Free Software Foundation, Inc.
 +
 +Author: Eli Zaretskii <eliz@gnu.org>
  
  This file is part of GNU Emacs.
  

diff --cc src/w32proc.c
Simple merge

diff --cc src/w32reg.c
index 4ddbaa3f26896ad081b50c292b3483daab120a10,e2aebbb1b76d6514f5cac9689b08f3566be43665..aff131dd37df0b8f13eb3e9a7f50489b00c04369
--- 1/src/w32reg.c
--- 2/src/w32reg.c
+++ b/src/w32reg.c
@@@ -1,8 -1,6 +1,8 @@@
  /* Emulate the X Resource Manager through the registry.
 -   Copyright (C) 1990, 1993-1994, 2001-2019 Free Software Foundation,
 -   Inc.
 +
- Copyright (C) 1990, 1993-1994, 2001-2018 Free Software Foundation, Inc.
++Copyright (C) 1990, 1993-1994, 2001-2019 Free Software Foundation, Inc.
 +
 +Author: Kevin Gallo
  
  This file is part of GNU Emacs.
  

diff --cc src/w32select.c
index dc568d47f278612bd8c4bc4e50d5122a0b42b5f5,6c7808d981304dd28f5a1ef9a2ae1525f2446299..1c84cb47eb1497d6443dc66de32afab706249a79
--- 1/src/w32select.c
--- 2/src/w32select.c
+++ b/src/w32select.c
@@@ -1,10 -1,7 +1,10 @@@
  /* Selection processing for Emacs on the Microsoft Windows API.
  
- Copyright (C) 1993-1994, 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 1993-1994, 2001-2019 Free Software Foundation, Inc.
  
 +Author: Kevin Gallo
 +      Benjamin Riefenstahl
 +
  This file is part of GNU Emacs.
  
  GNU Emacs is free software: you can redistribute it and/or modify

diff --cc src/w32term.c
Simple merge

diff --cc src/w32term.h
Simple merge

diff --cc src/w32uniscribe.c
Simple merge

diff --cc src/widget.c
Simple merge

diff --cc src/window.c
Simple merge

diff --cc src/window.h
Simple merge

diff --cc src/xdisp.c
Simple merge

diff --cc src/xfaces.c
Simple merge

diff --cc src/xfns.c
Simple merge

diff --cc src/xfont.c
Simple merge

diff --cc src/xftfont.c
Simple merge

diff --cc src/xmenu.c
index 31034f7112213d00406c5e6b5c5ad4e2d37e79e9,49cd5940eae49d240cc4b005892235b70841acbb..96c278d42d0c15e968b743111ae701cc585016be
--- 1/src/xmenu.c
--- 2/src/xmenu.c
+++ b/src/xmenu.c
@@@ -1,12 -1,8 +1,12 @@@
  /* X Communication module for terminals which understand the X protocol.
  
- Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2018 Free Software
+ Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2019 Free Software
  Foundation, Inc.
  
 +Author: Jon Arnold
 +      Roman Budzianowski
 +      Robert Krawitz
 +
  This file is part of GNU Emacs.
  
  GNU Emacs is free software: you can redistribute it and/or modify

diff --cc src/xml.c
Simple merge

diff --cc src/xrdb.c
Simple merge

diff --cc src/xselect.c
Simple merge

diff --cc src/xsettings.c
Simple merge

diff --cc src/xterm.c
Simple merge

diff --cc src/xterm.h
Simple merge

diff --cc src/xwidget.c
Simple merge

diff --cc src/xwidget.h
Simple merge

diff --cc test/Makefile.in
Simple merge

diff --cc test/README
Simple merge

diff --cc test/data/emacs-module/mod-test.c
Simple merge

diff --cc test/lisp/abbrev-tests.el
Simple merge

diff --cc test/lisp/auth-source-pass-tests.el
Simple merge

diff --cc test/lisp/auth-source-tests.el
Simple merge

diff --cc test/lisp/autorevert-tests.el
Simple merge

diff --cc test/lisp/calendar/icalendar-tests.el
Simple merge

diff --cc test/lisp/calendar/parse-time-tests.el
Simple merge

diff --cc test/lisp/calendar/todo-mode-tests.el
Simple merge

diff --cc test/lisp/char-fold-tests.el
Simple merge

diff --cc test/lisp/comint-tests.el
Simple merge

diff --cc test/lisp/dired-aux-tests.el
Simple merge

diff --cc test/lisp/dired-tests.el
Simple merge

diff --cc test/lisp/electric-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/benchmark-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/bytecomp-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/cl-lib-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/cl-macs-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/cl-print-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/edebug-resources/edebug-test-code.el
Simple merge

diff --cc test/lisp/emacs-lisp/edebug-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/eieio-tests/eieio-test-methodinvoke.el
Simple merge

diff --cc test/lisp/emacs-lisp/eieio-tests/eieio-test-persist.el
Simple merge

diff --cc test/lisp/emacs-lisp/eieio-tests/eieio-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/ert-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/generator-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/map-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/package-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/pcase-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/ring-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/rx-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/seq-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/subr-x-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/testcover-resources/testcases.el
Simple merge

diff --cc test/lisp/emacs-lisp/testcover-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/thunk-tests.el
Simple merge

diff --cc test/lisp/emacs-lisp/timer-tests.el
Simple merge

diff --cc test/lisp/epg-tests.el
Simple merge

diff --cc test/lisp/eshell/em-ls-tests.el
Simple merge

diff --cc test/lisp/eshell/eshell-tests.el
Simple merge

diff --cc test/lisp/filenotify-tests.el
Simple merge

diff --cc test/lisp/files-tests.el
Simple merge

diff --cc test/lisp/gnus/gnus-tests.el
Simple merge

diff --cc test/lisp/gnus/message-tests.el
Simple merge

diff --cc test/lisp/help-fns-tests.el
Simple merge

diff --cc test/lisp/hi-lock-tests.el
Simple merge

diff --cc test/lisp/htmlfontify-tests.el
Simple merge

diff --cc test/lisp/info-xref-tests.el
Simple merge

diff --cc test/lisp/json-tests.el
Simple merge

diff --cc test/lisp/ls-lisp-tests.el
Simple merge

diff --cc test/lisp/mouse-tests.el
Simple merge

diff --cc test/lisp/net/gnutls-tests.el
Simple merge

diff --cc test/lisp/net/tramp-tests.el
Simple merge

diff --cc test/lisp/progmodes/bat-mode-tests.el
Simple merge

diff --cc test/lisp/progmodes/flymake-tests.el
Simple merge

diff --cc test/lisp/progmodes/python-tests.el
Simple merge

diff --cc test/lisp/progmodes/ruby-mode-tests.el
Simple merge

diff --cc test/lisp/replace-tests.el
Simple merge

diff --cc test/lisp/ses-tests.el
Simple merge

diff --cc test/lisp/shell-tests.el
Simple merge

diff --cc test/lisp/simple-tests.el
Simple merge

diff --cc test/lisp/subr-tests.el
Simple merge

diff --cc test/lisp/term-tests.el
Simple merge

diff --cc test/lisp/textmodes/css-mode-tests.el
Simple merge

diff --cc test/lisp/textmodes/sgml-mode-tests.el
Simple merge

diff --cc test/lisp/thingatpt-tests.el
Simple merge

diff --cc test/lisp/url/url-util-tests.el
Simple merge

diff --cc test/lisp/vc/diff-mode-tests.el
Simple merge

diff --cc test/lisp/vc/vc-bzr-tests.el
Simple merge

diff --cc test/lisp/vc/vc-tests.el
Simple merge

diff --cc test/lisp/xdg-tests.el
Simple merge

diff --cc test/manual/cedet/semantic-ia-utest.el
Simple merge

diff --cc test/manual/cedet/semantic-tests.el
Simple merge

diff --cc test/src/buffer-tests.el
Simple merge

diff --cc test/src/data-tests.el
Simple merge

diff --cc test/src/editfns-tests.el
Simple merge

diff --cc test/src/emacs-module-tests.el
Simple merge

diff --cc test/src/eval-tests.el
Simple merge

diff --cc test/src/fileio-tests.el
Simple merge

diff --cc test/src/floatfns-tests.el
Simple merge

diff --cc test/src/fns-tests.el
Simple merge

diff --cc test/src/lread-tests.el
Simple merge

diff --cc test/src/print-tests.el
Simple merge

diff --cc test/src/process-tests.el
Simple merge

diff --cc test/src/regex-emacs-tests.el
index 7a075908a6b4ed0e4c5f5deace192ba6b6fa35bc,0000000000000000000000000000000000000000..e84af6b131b98ba8c562a4f0c61d7190999a259e
mode 100644,000000..100644
--- 1/test/src/regex-emacs-tests.el
--- /dev/null
+++ b/test/src/regex-emacs-tests.el
@@@ -1,686 -1,0 +1,686 @@@
- ;; Copyright (C) 2015-2018 Free Software Foundation, Inc.
 +;;; regex-emacs-tests.el --- tests for regex-emacs.c -*- lexical-binding: t -*-
 +
++;; Copyright (C) 2015-2019 Free Software Foundation, Inc.
 +
 +;; This file is part of GNU Emacs.
 +
 +;; GNU Emacs is free software: you can redistribute it and/or modify
 +;; it under the terms of the GNU General Public License as published by
 +;; the Free Software Foundation, either version 3 of the License, or
 +;; (at your option) any later version.
 +
 +;; GNU Emacs is distributed in the hope that it will be useful,
 +;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +;; GNU General Public License for more details.
 +
 +;; You should have received a copy of the GNU General Public License
 +;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
 +
 +;;; Code:
 +
 +(require 'ert)
 +
 +(defvar regex-tests--resources-dir
 +  (concat (concat (file-name-directory (or load-file-name buffer-file-name))
 +                  "/regex-resources/"))
 +  "Path to regex-resources directory next to the \"regex-emacs-tests.el\" file.")
 +
 +(ert-deftest regex-word-cc-fallback-test ()
 +  "Test that \"[[:cc:]]*x\" matches \"x\" (bug#24020).
 +
 +Test that a regex of the form \"[[:cc:]]*x\" where CC is
 +a character class which matches a multibyte character X, matches
 +string \"x\".
 +
 +For example, \"[[:word:]]*\u2620\" regex (note: \u2620 is a word
 +character) must match a string \"\u2420\"."
 +  (dolist (class '("[[:word:]]" "\\sw"))
 +    (dolist (repeat '("*" "+"))
 +      (dolist (suffix '("" "b" "bar" "\u2620"))
 +        (dolist (string '("" "foo"))
 +          (when (not (and (string-equal repeat "+")
 +                          (string-equal string "")))
 +            (should (string-match (concat "^" class repeat suffix "$")
 +                                  (concat string suffix)))))))))
 +
 +(defun regex--test-cc (name matching not-matching)
 +  (let (case-fold-search)
 +    (should (string-match-p (concat "^[[:" name ":]]*$") matching))
 +    (should (string-match-p (concat "^[[:" name ":]]*?\u2622$")
 +                            (concat matching "\u2622")))
 +    (should (string-match-p (concat "^[^[:" name ":]]*$") not-matching))
 +    (should (string-match-p (concat "^[^[:" name ":]]*\u2622$")
 +                            (concat not-matching "\u2622")))
 +    (with-temp-buffer
 +      (insert matching)
 +      (let ((p (point)))
 +        (insert not-matching)
 +        (goto-char (point-min))
 +        (skip-chars-forward (concat "[:" name ":]"))
 +        (should (equal (point) p))
 +        (skip-chars-forward (concat "^[:" name ":]"))
 +        (should (equal (point) (point-max)))
 +        (goto-char (point-min))
 +        (skip-chars-forward (concat "[:" name ":]\u2622"))
 +        (should (or (equal (point) p) (equal (point) (1+ p))))))))
 +
 +(dolist (test '(("alnum" "abcABC012łąka" "-, \t\n")
 +                ("alpha" "abcABCłąka" "-,012 \t\n")
 +                ("digit" "012" "abcABCłąka-, \t\n")
 +                ("xdigit" "0123aBc" "łąk-, \t\n")
 +                ("upper" "ABCŁĄKA" "abc012-, \t\n")
 +                ("lower" "abcłąka" "ABC012-, \t\n")
 +
 +                ("word" "abcABC012\u2620" "-, \t\n")
 +
 +                ("punct" ".,-" "abcABC012\u2620 \t\n")
 +                ("cntrl" "\1\2\t\n" ".,-abcABC012\u2620 ")
 +                ("graph" "abcłąka\u2620-," " \t\n\1")
 +                ("print" "abcłąka\u2620-, " "\t\n\1")
 +
 +                ("space" " \t\n\u2001" "abcABCł0123")
 +                ("blank" " \t\u2001" "\n")
 +
 +                ("ascii" "abcABC012 \t\n\1" "łą\u2620")
 +                ("nonascii" "łą\u2622" "abcABC012 \t\n\1")
 +                ("unibyte" "abcABC012 \t\n\1" "łą\u2622")
 +                ("multibyte" "łą\u2622" "abcABC012 \t\n\1")))
 +  (let ((name (intern (concat "regex-tests-" (car test) "-character-class")))
 +        (doc (concat "Perform sanity test of regexes using " (car test)
 +                     " character class.
 +
 +Go over all the supported character classes and test whether the
 +classes and their inversions match what they are supposed to
 +match.  The test is done using `string-match-p' as well as
 +`skip-chars-forward'.")))
 +    (eval `(ert-deftest ,name () ,doc ,(cons 'regex--test-cc test)) t)))
 +
 +
 +(defmacro regex-tests-generic-line (comment-char test-file whitelist &rest body)
 +  "Reads a line of the test file TEST-FILE, skipping
 +comments (defined by COMMENT-CHAR), and evaluates the tests in
 +this line as defined in the BODY.  Line numbers in the WHITELIST
 +are known failures, and are skipped."
 +
 +  `(with-temp-buffer
 +    (modify-syntax-entry ?_ "w;; ") ; tests expect _ to be a word
 +    (insert-file-contents (concat regex-tests--resources-dir ,test-file))
 +    (let ((case-fold-search nil)
 +          (line-number 1)
 +          (whitelist-idx 0))
 +
 +      (goto-char (point-min))
 +
 +      (while (not (eobp))
 +        (let ((start (point)))
 +          (end-of-line)
 +          (narrow-to-region start (point))
 +
 +          (goto-char (point-min))
 +
 +          (when
 +              (and
 +               ;; ignore comments
 +               (save-excursion
 +                 (re-search-forward ,(concat "^[^" (string comment-char) "]") nil t))
 +
 +               ;; skip lines in the whitelist
 +               (let ((whitelist-next
 +                      (condition-case nil
 +                          (aref ,whitelist whitelist-idx) (args-out-of-range nil))))
 +                 (cond
 +                  ;; whitelist exhausted. do process this line
 +                  ((null whitelist-next) t)
 +
 +                  ;; we're not yet at the next whitelist element. do
 +                  ;; process this line
 +                  ((< line-number whitelist-next) t)
 +
 +                  ;; we're past the next whitelist element. This
 +                  ;; shouldn't happen
 +                  ((> line-number whitelist-next)
 +                   (error
 +                    (format
 +                     "We somehow skipped the next whitelist element: line %d" whitelist-next)))
 +
 +                  ;; we're at the next whitelist element. Skip this
 +                  ;; line, and advance the whitelist index
 +                  (t
 +                   (setq whitelist-idx (1+ whitelist-idx)) nil))))
 +            ,@body)
 +
 +          (widen)
 +          (forward-line)
 +          (beginning-of-line)
 +          (setq line-number (1+ line-number)))))))
 +
 +(defun regex-tests-compare (string what-failed bounds-ref &optional substring-ref)
 +  "I just ran a search, looking at STRING.  WHAT-FAILED describes
 +what failed, if anything; valid values are 'search-failed,
 +'compilation-failed and nil.  I compare the beginning/end of each
 +group with their expected values.  This is done with either
 +BOUNDS-REF or SUBSTRING-REF; one of those should be non-nil.
 +BOUNDS-REF is a sequence \[start-ref0 end-ref0 start-ref1
 +end-ref1 ....] while SUBSTRING-REF is the expected substring
 +obtained by indexing the input string by start/end-ref.
 +
 +If the search was supposed to fail then start-ref0/substring-ref0
 +is 'search-failed.  If the search wasn't even supposed to compile
 +successfully, then start-ref0/substring-ref0 is
 +'compilation-failed.  If I only care about a match succeeding,
 +this can be set to t.
 +
 +This function returns a string that describes the failure, or nil
 +on success"
 +
 +  (when (or
 +         (and bounds-ref substring-ref)
 +         (not (or bounds-ref substring-ref)))
 +    (error "Exactly one of bounds-ref and bounds-ref should be non-nil"))
 +
 +  (let ((what-failed-ref (car (or bounds-ref substring-ref))))
 +
 +    (cond
 +     ((eq what-failed 'search-failed)
 +      (cond
 +       ((eq what-failed-ref 'search-failed)
 +        nil)
 +       ((eq what-failed-ref 'compilation-failed)
 +        "Expected pattern failure; but no match")
 +       (t
 +        "Expected match; but no match")))
 +
 +     ((eq what-failed 'compilation-failed)
 +      (cond
 +       ((eq what-failed-ref 'search-failed)
 +        "Expected no match; but pattern failure")
 +       ((eq what-failed-ref 'compilation-failed)
 +        nil)
 +       (t
 +        "Expected match; but pattern failure")))
 +
 +     ;; The regex match succeeded
 +     ((eq what-failed-ref 'search-failed)
 +      "Expected no match; but match")
 +     ((eq what-failed-ref 'compilation-failed)
 +      "Expected pattern failure; but match")
 +
 +     ;; The regex match succeeded, as expected. I now check all the
 +     ;; bounds
 +     (t
 +      (let ((idx 0)
 +            msg
 +            ref next-ref-function compare-ref-function mismatched-ref-function)
 +
 +        (if bounds-ref
 +            (setq ref bounds-ref
 +                  next-ref-function (lambda (x) (cddr x))
 +                  compare-ref-function (lambda (ref start-pos end-pos)
 +                                         (or (eq (car ref) t)
 +                                             (and (eq start-pos (car ref))
 +                                                  (eq end-pos   (cadr ref)))))
 +                  mismatched-ref-function (lambda (ref start-pos end-pos)
 +                                            (format
 +                                             "beginning/end positions: %d/%s and %d/%s"
 +                                             start-pos (car ref) end-pos (cadr ref))))
 +          (setq ref substring-ref
 +                next-ref-function (lambda (x) (cdr x))
 +                compare-ref-function (lambda (ref start-pos end-pos)
 +                                       (or (eq (car ref) t)
 +                                           (string= (substring string start-pos end-pos) (car ref))))
 +                mismatched-ref-function (lambda (ref start-pos end-pos)
 +                                          (format
 +                                           "beginning/end positions: %d/%s and %d/%s"
 +                                           start-pos (car ref) end-pos (cadr ref)))))
 +
 +        (while (not (or (null ref) msg))
 +
 +          (let ((start (match-beginning idx))
 +                (end   (match-end       idx)))
 +
 +            (when (not (funcall compare-ref-function ref start end))
 +              (setq msg
 +                    (format
 +                     "Have expected match, but mismatch in group %d: %s" idx (funcall mismatched-ref-function ref start end))))
 +
 +            (setq ref (funcall next-ref-function ref)
 +                  idx (1+ idx))))
 +
 +        (or msg
 +            nil))))))
 +
 +
 +
 +(defun regex-tests-match (pattern string bounds-ref &optional substring-ref)
 +  "I match the given STRING against PATTERN.  I compare the
 +beginning/end of each group with their expected values.
 +BOUNDS-REF is a sequence [start-ref0 end-ref0 start-ref1 end-ref1
 +....].
 +
 +If the search was supposed to fail then start-ref0 is
 +'search-failed.  If the search wasn't even supposed to compile
 +successfully, then start-ref0 is 'compilation-failed.
 +
 +This function returns a string that describes the failure, or nil
 +on success"
 +
 +  (if (string-match "\\[\\([\\.=]\\)..?\\1\\]" pattern)
 +      ;; Skipping test: [.x.] and [=x=] forms not supported by emacs
 +      nil
 +
 +    (regex-tests-compare
 +     string
 +     (condition-case nil
 +         (if (string-match pattern string) nil 'search-failed)
 +       ('invalid-regexp 'compilation-failed))
 +     bounds-ref substring-ref)))
 +
 +
 +(defconst regex-tests-re-even-escapes
 +  "\\(?:^\\|[^\\\\]\\)\\(?:\\\\\\\\\\)*"
 +  "Regex that matches an even number of \\ characters")
 +
 +(defconst regex-tests-re-odd-escapes
 +  (concat regex-tests-re-even-escapes "\\\\")
 +  "Regex that matches an odd number of \\ characters")
 +
 +
 +(defun regex-tests-unextend (pattern)
 +  "Basic conversion from extended regexes to emacs ones.  This is
 +mostly a hack that adds \\ to () and | and {}, and removes it if
 +it already exists.  We also change \\S (and \\s) to \\S- (and
 +\\s-) because extended regexes see the former as whitespace, but
 +emacs requires an extra symbol character"
 +
 +  (with-temp-buffer
 +    (insert pattern)
 +    (goto-char (point-min))
 +
 +    (while (re-search-forward "[()|{}]" nil t)
 +      ;; point is past special character. If it is escaped, unescape
 +      ;; it
 +
 +      (if (save-excursion
 +            (re-search-backward (concat regex-tests-re-odd-escapes ".\\=") nil t))
 +
 +          ;; This special character is preceded by an odd number of \,
 +          ;; so I unescape it by removing the last one
 +          (progn
 +            (forward-char -2)
 +            (delete-char 1)
 +            (forward-char 1))
 +
 +        ;; This special character is preceded by an even (possibly 0)
 +        ;; number of \. I add an escape
 +        (forward-char -1)
 +        (insert "\\")
 +        (forward-char 1)))
 +
 +    ;; convert \s to \s-
 +    (goto-char (point-min))
 +    (while (re-search-forward (concat regex-tests-re-odd-escapes "[Ss]") nil t)
 +      (insert "-"))
 +
 +    (buffer-string)))
 +
 +(defun regex-tests-BOOST-frob-escapes (s ispattern)
 +  "Mangle \\ the way it is done in frob_escapes() in
 +regex-tests-BOOST.c in glibc: \\t, \\n, \\r are interpreted;
 +\\\\, \\^, \{, \\|, \} are unescaped for the string (not
 +pattern)"
 +
 +  ;; this is all similar to (regex-tests-unextend)
 +  (with-temp-buffer
 +    (insert s)
 +
 +    (let ((interpret-list (list "t" "n" "r")))
 +      (while interpret-list
 +        (goto-char (point-min))
 +        (while (re-search-forward
 +                (concat "\\(" regex-tests-re-even-escapes "\\)"
 +                        "\\\\" (car interpret-list))
 +                nil t)
 +          (replace-match (concat "\\1" (car (read-from-string
 +                                             (concat "\"\\" (car interpret-list) "\""))))))
 +
 +        (setq interpret-list (cdr interpret-list))))
 +
 +    (when (not ispattern)
 +      ;; unescape \\, \^, \{, \|, \}
 +      (let ((unescape-list (list "\\\\" "^" "{" "|" "}")))
 +        (while unescape-list
 +          (goto-char (point-min))
 +          (while (re-search-forward
 +                  (concat "\\(" regex-tests-re-even-escapes "\\)"
 +                          "\\\\" (car unescape-list))
 +                  nil t)
 +            (replace-match (concat "\\1" (car unescape-list))))
 +
 +          (setq unescape-list (cdr unescape-list))))
 +      )
 +    (buffer-string)))
 +
 +
 +
 +
 +(defconst regex-tests-BOOST-whitelist
 +  [
 +   ;; emacs is more stringent with regexes involving unbalanced )
 +   63 65 69
 +
 +   ;; in emacs, regex . doesn't match \n
 +   91
 +
 +   ;; emacs is more forgiving with * and ? that don't apply to
 +   ;; characters
 +   107 108 109 122 123 124 140 141 142
 +
 +   ;; emacs accepts regexes with {}
 +   161
 +
 +   ;; emacs doesn't fail on bogus ranges such as [3-1] or [1-3-5]
 +   222 223
 +
 +   ;; emacs doesn't match (ab*)[ab]*\1 greedily: only 4 chars of
 +   ;; ababaaa match
 +   284 294
 +
 +   ;; ambiguous groupings are ambiguous
 +   443 444 445 446 448 449 450
 +
 +   ;; emacs doesn't know how to handle weird ranges such as [a-Z] and
 +   ;; [[:alpha:]-a]
 +   539 580 581
 +
 +   ;; emacs matches non-greedy regex ab.*? non-greedily
 +   639 677 712
 +   ]
 +  "Line numbers in the boost test that should be skipped.  These
 +are false-positive test failures that represent known/benign
 +differences in behavior.")
 +
 +;; - Format
 +;;   - Comments are lines starting with ;
 +;;   - Lines starting with - set options passed to regcomp() and regexec():
 +;;     - if no "REG_BASIC" is found, with have an extended regex
 +;;     - These set a flag:
 +;;       - REG_ICASE
 +;;       - REG_NEWLINE  (ignored by this function)
 +;;       - REG_NOTBOL
 +;;       - REG_NOTEOL
 +;;
 +;;   - Test lines are
 +;;     pattern string start0 end0 start1 end1 ...
 +;;
 +;;   - pattern, string can have escapes
 +;;   - string can have whitespace if enclosed in ""
 +;;   - if string is "!", then the pattern is supposed to fail compilation
 +;;   - start/end are of group0, group1, etc. group 0 is the full match
 +;;   - start<0 indicates "no match"
 +;;   - start is the 0-based index of the first character
 +;;   - end   is the 0-based index of the first character past the group
 +(defun regex-tests-BOOST ()
 +  (let (failures
 +        basic icase notbol noteol)
 +    (regex-tests-generic-line
 +     ?\; "BOOST.tests" regex-tests-BOOST-whitelist
 +     (if (save-excursion (re-search-forward "^-" nil t))
 +         (setq basic   (save-excursion (re-search-forward "REG_BASIC" nil t))
 +               icase   (save-excursion (re-search-forward "REG_ICASE" nil t))
 +               notbol  (save-excursion (re-search-forward "REG_NOTBOL" nil t))
 +               noteol  (save-excursion (re-search-forward "REG_NOTEOL" nil t)))
 +
 +       (save-excursion
 +         (or (re-search-forward "\\(\\S-+\\)\\s-+\"\\(.*\\)\"\\s-+?\\(.+\\)" nil t)
 +             (re-search-forward "\\(\\S-+\\)\\s-+\\(\\S-+\\)\\s-+?\\(.+\\)"  nil t)
 +             (re-search-forward "\\(\\S-+\\)\\s-+\\(!\\)"                    nil t)))
 +
 +       (let* ((pattern-raw   (match-string 1))
 +              (string-raw    (match-string 2))
 +              (positions-raw (match-string 3))
 +              (pattern (regex-tests-BOOST-frob-escapes pattern-raw t))
 +              (string  (regex-tests-BOOST-frob-escapes string-raw  nil))
 +              (positions
 +               (if (string= string "!")
 +                   (list 'compilation-failed 0)
 +                 (mapcar
 +                  (lambda (x)
 +                    (let ((x (string-to-number x)))
 +                      (if (< x 0) nil x)))
 +                  (split-string positions-raw)))))
 +
 +         (when (null (car positions))
 +           (setcar positions 'search-failed))
 +
 +         (when (not basic)
 +           (setq pattern (regex-tests-unextend pattern)))
 +
 +         ;; great. I now have all the data parsed. Let's use it to do
 +         ;; stuff
 +         (let* ((case-fold-search icase)
 +                (msg (regex-tests-match pattern string positions)))
 +
 +           (if (and
 +                ;; Skipping test: notbol/noteol not supported
 +                (not notbol) (not noteol)
 +
 +                msg)
 +
 +               ;; store failure
 +               (setq failures
 +                     (cons (format "line number %d: Regex '%s': %s"
 +                                   line-number pattern msg)
 +                           failures)))))))
 +
 +    failures))
 +
 +(defconst regex-tests-PCRE-whitelist
 +  [
 +   ;; ambiguous groupings are ambiguous
 +   610 611 1154 1157 1160 1168 1171 1176 1179 1182 1185 1188 1193 1196 1203
 +  ]
 +  "Line numbers in the PCRE test that should be skipped.  These
 +are false-positive test failures that represent known/benign
 +differences in behavior.")
 +
 +;; - Format
 +;;
 +;;  regex
 +;;  input_string
 +;;  group_num: group_match | "No match"
 +;;  input_string
 +;;  group_num: group_match | "No match"
 +;;  input_string
 +;;  group_num: group_match | "No match"
 +;;  input_string
 +;;  group_num: group_match | "No match"
 +;;  ...
 +(defun regex-tests-PCRE ()
 +  (let (failures
 +        pattern icase string what-failed matches-observed)
 +    (regex-tests-generic-line
 +     ?# "PCRE.tests" regex-tests-PCRE-whitelist
 +
 +     (cond
 +
 +      ;; pattern
 +      ((save-excursion (re-search-forward "^/\\(.*\\)/\\(.*i?\\)$" nil t))
 +       (setq icase (string= "i" (match-string 2))
 +             pattern (regex-tests-unextend (match-string 1))))
 +
 +      ;; string. read it in, match against pattern, and save all the results
 +      ((save-excursion (re-search-forward "^    \\(.*\\)" nil t))
 +       (let ((case-fold-search icase))
 +         (setq string (match-string 1)
 +
 +               ;; the regex match under test
 +               what-failed
 +               (condition-case nil
 +                   (if (string-match pattern string) nil 'search-failed)
 +                 ('invalid-regexp 'compilation-failed))
 +
 +               matches-observed
 +               (cl-loop for x from 0 to 20
 +                        collect (and (not what-failed)
 +                                     (or (match-string x string) "<unset>")))))
 +       nil)
 +
 +      ;; verification line: failed match
 +      ((save-excursion (re-search-forward "^No match" nil t))
 +       (unless what-failed
 +         (setq failures
 +               (cons (format "line number %d: Regex '%s': Expected no match; but match"
 +                             line-number pattern)
 +                     failures))))
 +
 +      ;; verification line: succeeded match
 +      ((save-excursion (re-search-forward "^ *\\([0-9]+\\): \\(.*\\)" nil t))
 +       (let* ((match-ref (match-string 2))
 +              (idx       (string-to-number (match-string 1))))
 +
 +         (if what-failed
 +             "Expected match; but no match"
 +           (unless (string= match-ref (elt matches-observed idx))
 +             (setq failures
 +                   (cons (format "line number %d: Regex '%s': Have expected match, but group %d is wrong: '%s'/'%s'"
 +                                 line-number pattern
 +                                 idx match-ref (elt matches-observed idx))
 +                         failures))))))
 +
 +      ;; reset
 +      (t (setq pattern nil) nil)))
 +
 +    failures))
 +
 +(defconst regex-tests-PTESTS-whitelist
 +  [
 +   ;; emacs doesn't barf on weird ranges such as [b-a], but simply
 +   ;; fails to match
 +   138
 +
 +   ;; emacs doesn't see DEL (0x78) as a [:cntrl:] character
 +   168
 +  ]
 +  "Line numbers in the PTESTS test that should be skipped.  These
 +are false-positive test failures that represent known/benign
 +differences in behavior.")
 +
 +;; - Format
 +;;   - fields separated by ¦ (note: this is not a |)
 +;;   - start¦end¦pattern¦string
 +;;   - start is the 1-based index of the first character
 +;;   - end   is the 1-based index of the last  character
 +(defun regex-tests-PTESTS ()
 +  (let (failures)
 +    (regex-tests-generic-line
 +     ?# "PTESTS" regex-tests-PTESTS-whitelist
 +     (let* ((fields (split-string (buffer-string) "¦"))
 +
 +            ;; string has 1-based index of first char in the
 +            ;; match. -1 means "no match". -2 means "invalid
 +            ;; regex".
 +            ;;
 +            ;; start-ref is 0-based index of first char in the
 +            ;; match
 +            ;;
 +            ;; string==0 is a special case, and I have to treat
 +            ;; it as start-ref = 0
 +            (start-ref (let ((raw (string-to-number (elt fields 0))))
 +                         (cond
 +                          ((= raw -2) 'compilation-failed)
 +                          ((= raw -1) 'search-failed)
 +                          ((= raw  0) 0)
 +                          (t          (1- raw)))))
 +
 +            ;; string has 1-based index of last char in the
 +            ;; match. end-ref is 0-based index of first char past
 +            ;; the match
 +            (end-ref   (string-to-number (elt fields 1)))
 +            (pattern   (elt fields 2))
 +            (string    (elt fields 3)))
 +
 +       (let ((msg (regex-tests-match pattern string (list start-ref end-ref))))
 +         (when msg
 +           (setq failures
 +                 (cons (format "line number %d: Regex '%s': %s"
 +                               line-number pattern msg)
 +                       failures))))))
 +    failures))
 +
 +(defconst regex-tests-TESTS-whitelist
 +  [
 +   ;; emacs doesn't barf on weird ranges such as [b-a], but simply
 +   ;; fails to match
 +   42
 +
 +   ;; emacs is more forgiving with * and ? that don't apply to
 +   ;; characters
 +   57 58 59 60
 +
 +   ;; emacs is more stringent with regexes involving unbalanced )
 +   67
 +  ]
 +  "Line numbers in the TESTS test that should be skipped.  These
 +are false-positive test failures that represent known/benign
 +differences in behavior.")
 +
 +;; - Format
 +;;   - fields separated by :. Watch for [\[:xxx:]]
 +;;   - expected:pattern:string
 +;;
 +;;   expected:
 +;;   | 0 | successful match      |
 +;;   | 1 | failed match          |
 +;;   | 2 | regcomp() should fail |
 +(defun regex-tests-TESTS ()
 +  (let (failures)
 +    (regex-tests-generic-line
 +     ?# "TESTS" regex-tests-TESTS-whitelist
 +     (if (save-excursion (re-search-forward "^\\([^:]+\\):\\(.*\\):\\([^:]*\\)$" nil t))
 +         (let* ((what-failed
 +                 (let ((raw (string-to-number (match-string 1))))
 +                   (cond
 +                    ((= raw 2) 'compilation-failed)
 +                    ((= raw 1) 'search-failed)
 +                    (t         t))))
 +                (string  (match-string 3))
 +                (pattern (regex-tests-unextend (match-string 2))))
 +
 +           (let ((msg (regex-tests-match pattern string nil (list what-failed))))
 +             (when msg
 +               (setq failures
 +                     (cons (format "line number %d: Regex '%s': %s"
 +                                   line-number pattern msg)
 +                           failures)))))
 +
 +       (error "Error parsing TESTS file line: '%s'" (buffer-string))))
 +    failures))
 +
 +(ert-deftest regex-tests-BOOST ()
 +  "Tests of the regular expression engine.
 +This evaluates the BOOST test cases from glibc."
 +  (should-not (regex-tests-BOOST)))
 +
 +(ert-deftest regex-tests-PCRE ()
 +  "Tests of the regular expression engine.
 +This evaluates the PCRE test cases from glibc."
 +  (should-not (regex-tests-PCRE)))
 +
 +(ert-deftest regex-tests-PTESTS ()
 +  "Tests of the regular expression engine.
 +This evaluates the PTESTS test cases from glibc."
 +  (should-not (regex-tests-PTESTS)))
 +
 +(ert-deftest regex-tests-TESTS ()
 +  "Tests of the regular expression engine.
 +This evaluates the TESTS test cases from glibc."
 +  (should-not (regex-tests-TESTS)))
 +
 +(ert-deftest regex-repeat-limit ()
 +  "Test the #xFFFF repeat limit."
 +  (should (string-match "\\`x\\{65535\\}" (make-string 65535 ?x)))
 +  (should-not (string-match "\\`x\\{65535\\}" (make-string 65534 ?x)))
 +  (should-error (string-match "\\`x\\{65536\\}" "X") :type 'invalid-regexp))
 +
 +;;; regex-emacs-tests.el ends here

diff --cc test/src/thread-tests.el
Simple merge