(Update: OK, it all seems so easy now (NOT). Input could be done

synchronously (with wait_reading_process_input), or asynchronously

by SIGIO or polling (SIGALRM). C-g either sets the Vquit_flag,

-- Replace wrong_kboard_jmpbuf with a special return value of

read_char. It is absurd that we use setjmp/longjmp just to return

@code{scroll-up-aggressively} / @code{scroll-down-aggressively}.

@vindex scroll-margin

The variable @code{scroll-margin} restricts how close point can come

to the top or bottom of a window (even if aggressive scrolling

specifies a fraction @var{f} that is larger than the window portion

@node Horizontal Scrolling

@section Horizontal Scrolling

Display a help message about these options.

@end table

@kbd{C-x C-c}, the key sequence to exit Emacs, invokes

@code{save-some-buffers} and therefore asks the same questions.

Here are some other commands that find matches for a regular

expression. They all ignore case in matching, if the pattern contains

no upper-case letters and @code{case-fold-search} is non-@code{nil}.

@findex list-matching-lines

@findex occur

@cindex mode, Occur

@cindex match (face name)

@vindex list-matching-lines-default-context-lines

@kindex M-s o

@item M-x occur

@itemx M-s o

buffer that contains a match for it. If you type @kbd{M-n} at the

prompt, you can reuse search strings from previous incremental

searches. The text that matched is highlighted using the @code{match}

You can also run @kbd{M-s o} when an incremental search is active;

this uses the current search string.

@findex occur

The @code{occur} command shows all the lines in the current buffer

@findex global-unset-key

@cindex Unbinding key

@itemize @bullet

@item

@item

The state of keyboard macro execution is saved and restored. While

non-@code{nil}, it saves all the file-visiting buffers without querying

the user.

a function of no arguments. It will be called in each buffer to decide

whether to offer to save that buffer. If it returns a non-@code{nil}

value in a certain buffer, that means do offer to save that buffer.

if (!NILP (val))

break;

args = XCDR (args);

@}

@end group

occur via calls to @code{eval_sub} or @code{Feval}, either directly or

indirectly.

checks whether the user pressed @kbd{C-g}, and if so, aborts the

processing. You should do that in any loop that can potentially

require a large number of iterations; in this case, the list of

or @code{(nthcdr 2 @var{cons-cell})}.

@end defun

@defun butlast x &optional n

This function returns the list @var{x} with the last element,

or the last @var{n} elements, removed. If @var{n} is greater

The connection type: @samp{plain} or @samp{tls}.

@end table

@end table

@end defun

out of the margin, closer to the center of the window.

@end defopt

@defopt scroll-conservatively

This variable controls how scrolling is done automatically when point

moves off the screen (or into the scroll margin). If the value is a

@item brace-list-close

Close brace of an enum or static array list. @ref{Brace List Symbols}.

@item brace-list-intro

@item brace-list-entry

Subsequent lines in an enum or static array list. @ref{Brace List

Symbols}.

Here, you've already seen the analysis of lines 1, 2, 3, and 11. On

line 4, things get interesting; this line is assigned

@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

@node External Scope Symbols, Paren List Symbols, Brace List Symbols, Syntactic Symbols

@comment ------------------------------------------------------------

@defun c-lineup-cpp-define

@findex lineup-cpp-define (c-)

Line up macro continuation lines according to the indentation of the

@defun cl-caddr x

This function is equivalent to @code{(car (cdr (cdr @var{x})))}.

where @var{xxx} is up to four @samp{a}s and/or @samp{d}s.

All of these functions are @code{setf}-able, and calls to them

are expanded inline by the byte-compiler for maximum efficiency.

but that's not necessary unless the value contains white space. So

@samp{filename=/home/user/#hello$^yes} is perfectly valid.

The following parameters have meaning in @acronym{MML}; parameters that have no

meaning are ignored. The @acronym{MML} parameter names are the same as the

@acronym{MIME} parameter names; the things in the parentheses say which

@findex gnus-summary-sort-by-chars

Sort by article length (@code{gnus-summary-sort-by-chars}).

@item C-c C-s C-i

@kindex C-c C-s C-i (Summary)

@findex gnus-summary-sort-by-score

@kindex D (Server)

@findex gnus-server-deny-server

Mark the current server as unreachable

@item M-o

@kindex M-o (Server)

@table @kbd

@findex nnmairix-widget-search-from-this-article

Allows you to create a mairix query or group based on the current

message using graphical widgets (same as @code{nnmairix-widget-search})

(@code{nnmairix-widget-search-from-this-article}).

@findex nnmairix-create-search-group-from-message

Interactively creates a new search group with query based on the current

message, but uses the minibuffer instead of graphical widgets

(@code{nnmairix-create-search-group-from-message}).

@findex nnmairix-search-thread-this-article

Searches thread for the current article

(@code{nnmairix-search-thread-this-article}). This is effectively a

shortcut for calling @code{nnmairix-search} with @samp{m:msgid} of the

current article and enabled threads.

@findex nnmairix-search-from-this-article

Searches all messages from sender of the current article

(@code{nnmairix-search-from-this-article}). This is a shortcut for

calling @code{nnmairix-search} with @samp{f:From}.

@findex nnmairix-goto-original-article

(Only in @code{nnmairix} groups!) Tries determine the group this article

originally came from and displays the article in this group, so that,

function will use the registry if available, but can also parse the

article file name as a fallback method.

@findex nnmairix-remove-tick-mark-original-article

Remove possibly existing tick mark from original article

(@code{nnmairix-remove-tick-mark-original-article}). (@pxref{nnmairix

So far so good---but how do you remove the tick marks in the @code{nnmairix}

group? There are two options: You may simply use

tick marks from the original article. The other possibility is to set

@code{nnmairix-propagate-marks-to-nnmairix-groups} to @code{t}, but see the above

comments about this option. If it works for you, the tick marks should

% Load plain if necessary, i.e., if running under initex.

\expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi

%

%

% Copyright 1985, 1986, 1988, 1990, 1991, 1992, 1993, 1994, 1995,

% 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,

% Give the space character the catcode for a space.

\def\spaceisspace{\catcode`\ =10\relax}

\chardef\dashChar = `\-

\chardef\slashChar = `\/

\chardef\underChar = `\_

% @comment ...line which is ignored...

% @c is the same as @comment

% @ignore ... @end ignore is another way to write a comment

\def\c{\begingroup \catcode`\^^M=\active%

\catcode`\@=\other \catcode`\{=\other \catcode`\}=\other%

\cxxx}

{\catcode`\^^M=\active \gdef\cxxx#1^^M{\endgroup}}

% @paragraphindent NCHARS

% We'll use ems for NCHARS, close enough.

}

\fi

% alias because \c means cedilla in @tex or @math

\let\texinfoc=\c

\catcode`\\=\active

%

% Process the macro body under the current catcode regime.

%

\catcode`\@=\savedcatcodeone

\catcode`\\=\savedcatcodetwo

%

% The \texinfoc is to remove the \newlinechar added by \scantokens, and

% can be noticed by \parsearg.

% We avoid surrounding the call to \scantokens with \bgroup and \egroup

% to allow macros to open or close groups themselves.

}

\ifcase\paramno

% 0

\expandafter\xdef\csname\the\macname\endcsname{%

\noexpand\scanmacro{\macrobody}}%

\or % 1

\expandafter\xdef\csname\the\macname\endcsname{%

handle SIGINT stop nopass

After this 'handle' command, SIGINT will return control to GDB. If

See the GDB manual for more details about signal handling and the

'handle' command.

** 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

---

The group 'wp', whose label was "text", is now deprecated.

"/~" on the remote host "foo", you can prevent it from being

substituted by a home directory by writing it as "/foo:/:/~/file".



* Editing Changes in Emacs 26.1

+++

** New bindings for 'query-replace-map'.

'undo', undo the last replacement; bound to 'u'.

'undo-all', undo all replacements; bound to 'U'.

*** Two new commands 'Buffer-menu-unmark-all', bound to 'U' and

'Buffer-menu-unmark-all-buffers', bound to 'M-DEL'.

** Ibuffer

---

breakpoint (e.g. with "f" and "o") by customizing the new option

'edebug-sit-on-break'.

** Eshell

*** 'eshell-input-filter's value is now a named function

Completion candidates for HTML classes and IDs are retrieved from open

HTML mode buffers.

+++

** Emacs now supports character name escape sequences in character and

string literals. The syntax variants \N{character name} and



* Lisp Changes in Emacs 26.1

** New variable 'while-no-input-ignore-events' which allow

setting which special events 'while-no-input' should ignore.

It is a list of symbols.

that are not built-in primitives. We recommend using this new

function instead of 'subr-arity'.

+++

** 'parse-partial-sexp' state has a new element. Element 10 is

non-nil when the last character scanned might be the first character

collection).

+++

** The new functions 'make-nearby-temp-file' and 'temporary-file-directory'

can be used for creation of temporary files of remote or mounted directories.

/* Cases for lowercase hex letters, and lowercase letters, all offset by N. */

/* Cases for hex letters, digits, lower, punct, and upper. */

/* The mask is not what you might think.

When the ordinal i'th bit is set, insert a colon

before the i'th digit of the time zone representation. */

do \

{ \

digits = d; \

tz_colon_mask = mask; \

u_number_value = v; \

goto do_tz_offset; \

}

#endif

hour_diff = diff / 60 / 60;

min_diff = diff / 60 % 60;

sec_diff = diff % 60;

switch (colons)

{

case 0: /* +hhmm */

case 1: tz_hh_mm: /* +hh:mm */

case 2: tz_hh_mm_ss: /* +hh:mm:ss */

hour_diff * 10000 + min_diff * 100 + sec_diff);

case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */

goto tz_hh_mm_ss;

if (min_diff != 0)

goto tz_hh_mm;

default:

goto bad_format;

/* A sequence of null-terminated strings packed next to each other.

The strings are followed by an extra null byte. If TZ_IS_SET,

there must be at least one string and the first string (which is

Abbreviations are stored here because otherwise the values of

tm_zone and/or tzname would be dead after changing TZ and calling

/* Verify requirement R at compile-time, as a declaration without a

trailing ';'. */

#ifndef __has_builtin

# define __has_builtin(x) 0

(if user

(auth-source-search

:host host

:max 1

:require '(:user :secret)

:create nil)

(t "N/A"))))))



;;; `upowerd' interface.

(defsubst battery-upower-prop (pname &optional device)

(dbus-get-property

commands.")

(make-variable-buffer-local 'Buffer-menu-files-only)

(defvar Buffer-menu-mode-map

(let ((map (make-sparse-keymap))

(menu-map (make-sparse-keymap)))

(defun Buffer-menu--pretty-file-name (file)

(cond (file

(abbreviate-file-name file))

(t "")))

;;; buff-menu.el ends here

(unwind-protect

(progn

(sit-for 2)

(setq okay t))

(progn

(delete-region savemax (point-max))

;; Copyright (C) 1996, 2000-2017 Free Software Foundation, Inc.

(time-second 2digit)

(time-secfrac "\\(\\.[0-9]+\\)?")

(time-numoffset (concat "\\([-+]\\)" time-hour ":?" time-minute "?"))

(partial-time (concat time-hour colon time-minute colon time-second

time-secfrac))

(list (concat "^" full-date)

(concat "T" partial-time)

(concat "\\(Z\\|" time-numoffset "\\)")))

(time-re (nth 1 parse-time-iso8601-regexp))

(tz-re (nth 2 parse-time-iso8601-regexp))

re-start

day month year day-of-week dst tz)

;; We need to populate 'time' with

;; (SEC MIN HOUR DAY MON YEAR DOW DST TZ)

(setq hour (string-to-number (match-string 1 date-string))

minute (string-to-number (match-string 2 date-string))

seconds (string-to-number (match-string 3 date-string))

re-start (match-end 0))

(when (string-match tz-re date-string re-start)

(if (string= "Z" (match-string 1 date-string))

(scroll-step windows integer)

(scroll-conservatively windows integer)

(scroll-margin windows integer)

(hscroll-margin windows integer "22.1")

(hscroll-step windows number "22.1")

(truncate-partial-width-windows

Within CMD, %i denotes the input file(s), and %o denotes the

output file. %i path(s) are relative, while %o is absolute.")

;;;###autoload

(defun dired-do-compress-to ()

"Compress selected files and directories to an archive.

May contain all other options that don't contradict `-l';

may contain even `F', `b', `i' and `s'. See also the variable

`dired-ls-F-marks-symlinks' concerning the `F' switch.

On systems such as MS-DOS and MS-Windows, which use `ls' emulation in Lisp,

some of the `ls' switches are not supported; see the doc string of

`insert-directory' in `ls-lisp.el' for more details."

(defun doc-view-revert-buffer (&optional ignore-auto noconfirm)

"Like `revert-buffer', but preserves the buffer's current modes."

(interactive (list (not current-prefix-arg)))

(cl-labels ((revert ()

(let (revert-buffer-function)

(revert-buffer ignore-auto noconfirm 'preserve-modes))))

(unless doc-view-doc-type

(doc-view-set-doc-type))

(doc-view-set-up-single-converter)

(doc-view-make-safe-dir doc-view-cache-directory)

;; Handle compressed files, remote files, files inside archives

tail))

(t (cons 'list heads)))))

;;; backquote.el ends here

(when (eq 'setf (car-safe name))

(require 'gv)

(setq name (gv-setter (cadr name))))

,@(mapcar (lambda (declaration)

(let ((f (cdr (assq (car declaration)

defun-declarations-alist))))

(t (message "Warning: Unknown defun property `%S' in %S"

(car declaration) name)

nil))))

;;;###autoload

(defun cl-generic-define (name args options)

(declare (gv-setter (lambda (store) `(setcar (nthcdr 9 ,x) ,store))))

(nth 9 x))

;;(defun last* (x &optional n)

;; "Returns the last link in the list LIST.

copy-list

ldiff

list*

tenth

ninth

eighth

:type 'boolean

:group 'edebug)

(defcustom edebug-save-windows t

"If non-nil, Edebug saves and restores the window configuration.

That takes some time, so if your program does not care what happens to

(defvar edebug-after-dotted-spec nil)

(defvar edebug-matching-depth 0) ;; initial value

;;; Failure to match

buffer is killed; if there is an error, the test buffer is kept

around on error for further inspection. Its name is derived from

the name of the test and the result of NAME-FORM."

(indent 1))

`(ert--call-with-test-buffer ,name-form (lambda () ,@body)))

(kill-buffer clone)))))))

(provide 'ert-x)

;;; ert-x.el ends here

;; Author: Artur Malabarba <emacs@endlessparentheses.com>

;; Package-Requires: ((emacs "24.1"))

;; Keywords: extensions lisp

;; Prefix: let-alist

;; Separator: -

(functionp &rest form)

sexp))

;; Only called from edebug.

(declare-function get-edebug-spec "edebug" (symbol))

binding))

bindings)))

(declare (indent 2)

(debug ([&or (&rest (symbolp form)) (symbolp form)] form body)))

(when (and (<= (length bindings) 2)

,then

,@else)))

(declare (indent 1) (debug if-let))

(list 'if-let bindings (macroexp-progn body)))

(defsubst hash-table-empty-p (hash-table)

"Check whether HASH-TABLE is empty (has 0 elements)."

(zerop (hash-table-count hash-table)))

perform the requested window recentering or scrolling and ask

again.

The return value is the matching entry from the CHOICES list.

Usage example:

(inhibit-read-only t))

(if (> tabulated-list-padding 0)

(insert (make-string x ?\s)))

(insert ?\n)

;; Ever so slightly faster than calling `put-text-property' twice.

(add-text-properties

;; Usage:

;; Simply load this file into emacs (version 19 or higher)

;; The "-q" option prevents loading of your init file (commands

;; therein might confuse this program).

;;; Code:

;;;

;;; Decide Emacs Variant, GNU Emacs or XEmacs (aka Lucid Emacs).

;;; Determine Window System, and X Server Vendor (if appropriate).

;;;

;;; Key variables

;;;

(defvar edt-key nil)

(defvar edt-enter nil)

(defvar edt-return nil)

(defvar edt-save-function-key-map)

;;;

;;;

;;

;; Key definitions for the EDT emulation within GNU Emacs

;;

'(

EDT MAPPER

You will be asked to press keys to create a custom mapping (under a

just press RETURN at the prompt.

")

EDT MAPPER

You will be asked to press keys to create a custom mapping of your

"))

PRESS THE KEY SPECIFIED IN THE MINIBUFFER BELOW.

REMEMBER: JUST PRESS RETURN TO SKIP MAPPING A KEY.

")

GENERATING A CUSTOM CONFIGURATION FILE FOR TERMINAL TYPE: ")

PRESS THE KEY SPECIFIED IN THE MINIBUFFER BELOW.

REMEMBER: JUST PRESS RETURN TO SKIP MAPPING A KEY.")))

;;

;; Arrows

;;

")

;;

;; PF keys

;;

")

;;

;; KP0-9 KP- KP, KPP and KPE

;;

")

;;

;; Editing keypad (FIND, INSERT, REMOVE)

;; (SELECT, PREVIOUS, NEXT)

;;

")

;;

;; F1-14 Help Do F17-F20

;;

")

ADDITIONAL FUNCTION KEYS

Your keyboard may have additional function keys which do not correspond

When you are done, just press RETURN at the \"EDT Key Name:\" prompt.

")

;;

;; Extra Keys

;;

")

)

)

")

;;; edt-mapper.el ends here

;;; INITIALIZATION COMMANDS.

;;;

;;;

;;; Function used to load LK-201 key mapping file generated by edt-mapper.el.

;;;

You can do this by quitting Emacs and then invoking Emacs again as

follows:

[NOTE: If you do nothing out of the ordinary in your init file, and

the search for edt-mapper is successful, you can try running it now.]

(insert (format

"Ah yes, there it is, in \n\n %s \n\n" path))

(if (edt-y-or-n-p "Do you want to run it now? ")

(error "EDT Emulation not configured")))

(insert (substitute-command-keys

"Nope, I can't seem to find it. :-(\n\n"))

(let* ((file-name (or (buffer-file-name)

;; Handle non-file buffers, too.

(expand-file-name default-directory)))

;; FIXME: Why not use file-relative-name?

(substring file-name (length root)))))

(condition-case err

"Non-nil means `save-some-buffers' should save this buffer without asking.")

(make-variable-buffer-local 'buffer-save-without-query)

(defun save-some-buffers (&optional arg pred)

"Save some modified file-visiting buffers. Asks user about each one.

You can answer `y' to save, `n' not to save, `C-r' to look at the

If PRED is t, then certain non-file buffers will also be considered.

If PRED is a zero-argument function, it indicates for each buffer whether

to consider it or not when called with that buffer current.

See `save-some-buffers-action-alist' if you want to

change the additional actions you can take on files."

(interactive "P")

(save-window-excursion

(let* (queried autosaved-buffers

files-done abbrevs-done)

(unless (equal switches "")

;; Split the switches at any spaces so we can

;; pass separate options as separate args.

;; Avoid lossage if FILE starts with `-'.

'("--")

(progn

Runs the members of `kill-emacs-query-functions' in turn and stops

if any returns nil. If `confirm-kill-emacs' is non-nil, calls it."

(interactive "P")

(save-some-buffers arg t)

(let ((confirm confirm-kill-emacs))

(and

(integer :value 200)

(number :value 4.0)

function

:group 'gnus-article-signature)

(defcustom gnus-hidden-properties

;; (modify-syntax-entry ?- "w" table)

(modify-syntax-entry ?> ")<" table)

(modify-syntax-entry ?< "(>" table)

table)

"Syntax table used in article mode buffers.

Initialized from `text-mode-syntax-table'.")

(let ((keymap (copy-keymap gnus-article-mode-map))

(map (copy-keymap gnus-article-send-map))

(sumkeys (where-is-internal 'gnus-article-read-summary-keys))

parent agent draft)

(define-key keymap "S" map)

(define-key map [t] nil)

(with-current-buffer gnus-article-current-summary

(set-keymap-parent

keymap

(if (setq parent (keymap-parent gnus-article-mode-map))

(prog1

(setq parent (copy-keymap parent))

(set-keymap-parent map (key-binding "S"))

(let (key def gnus-pick-mode)

(while sumkeys

(gnus-setup-message 'message

(message-mail to subject other-headers continue

nil yank-action send-actions return-action)))

(when switch-action

(setq mail-buf (current-buffer))

(switch-to-buffer buf)

(message-pop-to-buffer "*Gnus Bug*"))

(let ((message-this-is-mail t))

(message-setup `((To . ,gnus-maintainer)

(when gnus-bug-create-help-buffer

(push `(gnus-bug-kill-buffer) message-send-actions))

(goto-char (point-min))

(defvar gnus-pick-line-number 1)

(defun gnus-pick-line-number ()

"Return the current line number."

(defun gnus-pick-start-reading (&optional catch-up)

"Start reading the picked articles.

(gnus-run-hooks 'gnus-save-newsrc-hook)

(if gnus-slave

(gnus-slave-save-newsrc)

(gnus-message 8 "Saving %s..." gnus-current-startup-file)

(gnus-gnus-to-newsrc-format)

(gnus-message 8 "Saving %s...done" gnus-current-startup-file))

"\C-c\C-s\C-m\C-n" gnus-summary-sort-by-most-recent-number

"\C-c\C-s\C-l" gnus-summary-sort-by-lines

"\C-c\C-s\C-c" gnus-summary-sort-by-chars

"\C-c\C-s\C-a" gnus-summary-sort-by-author

"\C-c\C-s\C-t" gnus-summary-sort-by-recipient

"\C-c\C-s\C-s" gnus-summary-sort-by-subject

["Sort by score" gnus-summary-sort-by-score t]

["Sort by lines" gnus-summary-sort-by-lines t]

["Sort by characters" gnus-summary-sort-by-chars t]

["Randomize" gnus-summary-sort-by-random t]

["Original sort" gnus-summary-sort-by-original t])

("Help"

;; The group was successfully selected.

(t

(gnus-set-global-variables)

(when (boundp 'spam-install-hooks)

(spam-initialize))

;; Save the active value in effect when the group was entered.

(when kill-buffer

(gnus-kill-or-deaden-summary kill-buffer))

(gnus-summary-auto-select-subject)

;; Show first unread article if requested.

(if (and (not no-article)

(not no-display)

(gnus-article-sort-by-chars

(gnus-thread-header h1) (gnus-thread-header h2)))

(defsubst gnus-article-sort-by-author (h1 h2)

"Sort articles by root author."

(gnus-string<

(interactive "P")

(gnus-summary-sort 'chars reverse))

(defun gnus-summary-sort-by-original (&optional reverse)

"Sort the summary buffer using the default sorting method.

Argument REVERSE means reverse order."

The variable `gnus-default-article-saver' specifies the saver function.

If the optional second argument NOT-SAVED is non-nil, articles saved

(interactive "P")

(require 'gnus-art)

(let* ((articles (gnus-summary-work-articles n))

(parent (gnus-topic-parent-topic topic))

(grandparent (gnus-topic-parent-topic parent)))

(unless grandparent

(when topic

(gnus-topic-goto-topic topic)

(gnus-topic-kill-group)

"submit@debbugs.gnu.org (The Gnus Bugfixing Girls + Boys)"

"The mail address of the Gnus maintainers.")

(defvar gnus-info-nodes

'((gnus-group-mode "(gnus)Group Buffer")

(gnus-summary-mode "(gnus)Summary Buffer")

"Mangles FollowUp-To and Newsgroups header to point to TARGET-GROUP.

With prefix-argument just set Follow-Up, don't cross-post."

(interactive

(message-remove-header "Follow[Uu]p-[Tt]o" t)

(message-goto-newsgroups)

(beginning-of-line)

"Crossposts message and set Followup-To to TARGET-GROUP.

With prefix-argument just set Follow-Up, don't cross-post."

(interactive

(when (fboundp 'gnus-group-real-name)

(setq target-group (gnus-group-real-name target-group)))

(cond ((not (or (null target-group) ; new subject not empty

(looking-at "[ \t]*\n"))

(expand-abbrev))

(push-mark)

(goto-char (point-min))

(or (search-forward (concat "\n" mail-header-separator "\n") nil t)

(defun message-in-body-p ()

"Return t if point is in the message body."

(>= (point)

(save-excursion

(defun message-goto-eoh ()

"Move point to the end of the headers."

"Insert four newlines, and then reformat if inside quoted text.

Prefix arg means justify as well."

(interactive (list (if current-prefix-arg 'full)))

(let (quoted point beg end leading-space bolp fill-paragraph-function)

(setq point (point))

(beginning-of-line)

(let ((inhibit-read-only t))

(put-text-property (point-min) (point-max) 'read-only nil))

(message-fix-before-sending)

(run-hooks 'message-send-hook)

(when message-confirm-send

(or (y-or-n-p "Send message? ")

(keyboard-quit)))

(forward-line 1)

(unless (y-or-n-p "Send anyway? ")

(error "Failed to send the message")))))

;; Let the user do all of the above.

(run-hooks 'message-header-hook))

(setq options message-options)

(setq message-options options)

(push 'mail message-sent-message-via)))

(defvar sendmail-program)

(defvar smtpmail-smtp-server)

(defvar smtpmail-smtp-service)

"Process Fcc headers in the current buffer."

(let ((case-fold-search t)

(buf (current-buffer))

(insert-buffer-substring buf)

(message-encode-message-body)

(save-restriction

(message-narrow-to-headers)

(if (and (file-readable-p file) (mail-file-babyl-p file))

(rmail-output file 1 nil t)

(let ((mail-use-rfc822 t))

(defun message-output (filename)

"Append this article to Unix/babyl mail file FILENAME."

(not (string-match message-bogus-system-names message-user-fqdn)))

;; `message-user-fqdn' seems to be valid

message-user-fqdn)

;; `system-name' returned the right result.

sysname)

;; Try `mail-host-address'.

to continue editing a message already being composed. SWITCH-FUNCTION

is a function used to switch to and display the mail buffer."

(interactive)

;;;###autoload

(defun message-news (&optional newsgroups subject)

(equal (cdr (assq 'type (car cont))) "text/html"))

(setq cont (mml-expand-html-into-multipart-related (car cont))))

(prog1

(setq message-options options)

(cond

((and (consp (car cont))

(intern (downcase charset))))))

(if (and (not raw)

(member (car (split-string type "/")) '("text" "message")))

(progn

(with-temp-buffer

(cond

((eq (car cont) 'mml)

(let ((mml-boundary (mml-compute-boundary cont))

;; insert a "; format=flowed" string unless the

;; user has already specified it.

(setq flowed (null (assq 'format cont)))))

(setq encoding (mm-body-encoding

charset (cdr (assq 'encoding cont))))))

(setq coded (buffer-string)))

(mml-insert-mime-headers cont type charset encoding flowed)

(insert "\n")

(insert coded))

(cond

((cdr (assq 'buffer cont))

(insert (string-as-unibyte

((and filename

(not (equal (cdr (assq 'nofile cont)) "yes")))

(let ((coding-system-for-read mm-binary-coding-system))

(t

(let ((contents (cdr (assq 'contents cont))))

(if (multibyte-string-p contents)

(defun mml-minibuffer-read-file (prompt)

(let* ((completion-ignored-extensions nil)

(file (read-file-name prompt

(or mml-default-directory default-directory)

nil t)))

is a one-line description of the attachment. The DISPOSITION

specifies how the attachment is intended to be displayed. It can

be either \"inline\" (displayed automatically within the message

(interactive

(let* ((file (mml-minibuffer-read-file "Attach file: "))

(list file type description disposition)))

;; If in the message header, attach at the end and leave point unchanged.

(let ((head (unless (message-in-body-p) (point))))

(setq nndoc-dissection-alist nil)

(with-current-buffer nndoc-current-buffer

(erase-buffer)

;; Initialize the nndoc structures according to this new document.

(when (and nndoc-current-buffer

(not nndoc-dissection-alist))

(if (listp imap-shell-program)

(car imap-shell-program)

imap-shell-program)

(defvoo nnimap-inbox nil

"The mail box where incoming mail arrives and should be split out of.

(if fn

(format "Describe function (default %s): " fn)

"Describe function: ")

(and fn (symbol-name fn)))))

(unless (equal val "")

(setq fn (intern val)))

(unless (and fn (symbolp fn))

(user-error "You didn't specify a function symbol"))

(user-error "Symbol's function definition is void: %s" fn))

(list fn)))

(save-excursion

(with-help-window (help-buffer)

;; Use " is " instead of a colon so that

;; it is easier to get out the function name using forward-sexp.

(princ " is ")

(let ((fill-begin (point))

(high-usage (car high))

(high-doc (cdr high)))

(fill-region fill-begin (point))

high-doc)))))

(or (and advised

(advice--cd*r (advice--symbol-function function)))

function))

(def (if (symbolp real-function)

real-function))

(real-def (cond

((and aliased (not (subrp def)))

(let ((f real-function))

;; Print what kind of function-like object FUNCTION is.

(princ (cond ((or (stringp def) (vectorp def))

"a keyboard macro")

;; Aliases are Lisp functions, so we need to check

;; aliases before functions.

(aliased

(terpri)

(pp val)

;; Remove trailing newline.

(let* ((sv (get variable 'standard-value))

(origval (and (consp sv)

(condition-case nil

"\\(source \\(?:code \\)?\\(?:of\\|for\\)\\)\\)"

"[ \t\n]+\\)?"

;; Note starting with word-syntax character:

"Regexp matching doc string references to symbols.

The words preceding the quoted symbol can be used in doc strings to

such overlays in all buffers except the current one."

(let ((hlob hl-line-overlay-buffer)

(curbuf (current-buffer)))

(not (eq curbuf hlob))

(not (minibufferp)))

(with-current-buffer hlob

(defun hfy-which-etags ()

"Return a string indicating which flavor of etags we are using."

(defcustom hfy-etags-cmd

;; We used to wrap this in a `eval-and-compile', but:

(cl-assert (derived-mode-p 'ibuffer-mode)))

(defun ibuffer-buffer-file-name ()

(define-ibuffer-op ibuffer-do-save ()

"Save marked buffers as with `save-buffer'."

;; * WARNING: The "database" format used might be changed so keep a

;; backup of `image-dired-db-file' when testing new versions.

;;

;;

;; TODO

;; ====

:group 'image-dired)

(defcustom image-dired-cmd-create-thumbnail-options

"Options of command used to create thumbnail image.

Used with `image-dired-cmd-create-thumbnail-program'.

Available format specifiers are: %w which is replaced by

:group 'image-dired)

(defcustom image-dired-cmd-create-temp-image-options

"Options of command used to create temporary image for display window.

Used together with `image-dired-cmd-create-temp-image-program',

Available format specifiers are: %w and %h which are replaced by

:group 'image-dired)

(defcustom image-dired-cmd-create-standard-thumbnail-options

(unless (or image-dired-cmd-pngcrush-program

image-dired-cmd-pngnq-program)

(list

:group 'image-dired

(buffer-disable-undo)

(image-mode-setup-winprops)

(add-hook 'file-name-at-point-functions 'image-dired-file-name-at-point nil t))

(defvar image-dired-minor-mode-map

(if (memq (current-justification) '(center right))

(skip-chars-forward " \t")))

"Short cut function to indent region using `indent-according-to-mode'.

(defun indent-region (start end &optional column)

"Indent each nonblank line in the region.

(funcall indent-region-function start end))

;; Else, use a default implementation that calls indent-line-function on

;; each line.

;; In most cases, reindenting modifies the buffer, but it may also

;; leave it unmodified, in which case we have to deactivate the mark

;; by hand.

(setq deactivate-mark t))

(define-obsolete-function-alias 'indent-relative-maybe

'indent-relative-first-indent-point "26.1")

parameter-alist))

parameter-alist))

(defun Info-display-images-node ()

"Display images in current node."

(save-excursion

(setq Info-history-forward nil))

(if (not (eq Info-fontify-maximum-menu-size nil))

(Info-fontify-node))

(Info-display-images-node)

(Info-hide-cookies-node)

(run-hooks 'Info-selection-hook)))))

(ietf-drums-init string)

(while (not (eobp))

(setq c (char-after))

(cond

((or (eq c ? )

(eq c ?\t))

(encode-coding-region

(point-min) (point-max)

(mm-charset-to-coding-system

;; We found something that may perhaps be encoded.

(re-search-forward "^[^:]+: *" nil t)

(cond

See documentation for `make-obsolete-variable' for a description

of the arguments OBSOLETE-NAME, CURRENT-NAME, and perhaps WHEN

and ACCESS-TYPE. This macro is used by XEmacs that lacks WHEN and

ACCESS-TYPE arguments and by Emacs versions that lack ACCESS-TYPE,

introduced in Emacs 24."

(if (featurep 'xemacs)

"Directory where files will downloaded."

:version "24.4"

:group 'eww

;;;###autoload

(defcustom eww-suggest-uris

"Directory where bookmark files will be stored."

:version "25.1"

:group 'eww

(defcustom eww-desktop-remove-duplicates t

"Whether to remove duplicates from the history when saving desktop data.

(if uris (format " (default %s)" (car uris)) "")

": ")))

(list (read-string prompt nil nil uris))))

(setq url (string-trim url))

(cond ((string-match-p "\\`file:/" url))

;; Don't mangle file: URLs at all.

(setq url (concat url "/"))))

(setq url (concat eww-search-prefix

(replace-regexp-in-string " " "+" url))))))

;;;###autoload (defalias 'browse-web 'eww)

"utf-8"))))

(data-buffer (current-buffer))

last-coding-system-used)

(with-current-buffer buffer

(unwind-protect

(progn

(cond

((and eww-use-external-browser-for-content-type

(string-match-p eww-use-external-browser-for-content-type

(car content-type)))

((eww-html-p (car content-type))

(eww-display-html charset url nil point buffer encode))

((equal (car content-type) "application/pdf")

;;;###autoload

(defun eww-browse-url (url &optional new-window)

(when new-window

(eww-mode))

(eww url))

(erase-buffer)

(insert text)

(goto-char (plist-get elem :point))

(eww-update-header-line-format))))

(defun eww-next-url ()

(defun eww-download ()

"Download URL under point to `eww-download-directory'."

(interactive)

(let ((url (get-text-property (point) 'shr-url)))

(if (not url)

(message "No URL under point")

:nowait, if non-nil, says the connection should be made

asynchronously, if possible.

:tls-parameters is a list that should be supplied if you're

opening a TLS connection. The first element is the TLS

type (either `gnutls-x509pki' or `gnutls-anon'), and the

(defcustom shr-width nil

"Frame width to use for rendering.

May either be an integer specifying a fixed width in characters,

:version "25.1"

:type '(choice (integer :tag "Fixed width in characters")

(const :tag "Use the width of the window" nil))

(create-image data nil t :ascent 100

:format content-type))

((eq content-type 'image/svg+xml)

((eq size 'full)

(ignore-errors

(shr-rescale-image data content-type

image)

(insert (or alt ""))))

"Rescale DATA, if too big, to fit the current buffer.

(if (or (not (fboundp 'imagemagick-types))

(not (get-buffer-window (current-buffer))))

(create-image data nil t :ascent 100)

(let* ((edges (window-inside-pixel-edges

(get-buffer-window (current-buffer))))

(max-width (truncate (* shr-max-image-proportion

(max-height (truncate (* shr-max-image-proportion

(scaling (image-compute-scaling-factor image-scaling-factor)))

(when (or (and width

(> width max-width))

(when (ignore-errors

(url-cache-extract (url-cache-create-filename (shr-encode-url url)))

t)

(shr-parse-image-data)))))

(declare-function libxml-parse-xml-region "xml.c"

obarray)))))))

;; SVG images may contain references to further images that we may

;; want to block. So special-case these by parsing the XML data

(setq data

(shr-dom-to-xml

(libxml-parse-xml-region (point) (point-max)))))

(list data content-type)))

;;; Utility functions:

"Like `accept-process-output' for Tramp processes.

This is needed in order to hide `last-coding-system-used', which is set

for process communication also."

(with-current-buffer (process-buffer proc)

(let (buffer-read-only last-coding-system-used)

;; Under Windows XP, accept-process-output doesn't return

(defun tramp-check-for-regexp (proc regexp)

"Check, whether REGEXP is contained in process buffer of PROC.

"Returns all discovered Avahi service names as list."

(let (result)

(maphash

zeroconf-services-hash)

result))

"Returns all discovered Avahi service types as list."

(let (result)

(maphash

zeroconf-services-hash)

result))

format of SERVICE."

(let (result)

(maphash

(when (equal type (zeroconf-service-type value))

(add-to-list 'result value)))

zeroconf-services-hash)

(dun-mprincl "You can't drop anything while on the bus.")

(let (objnum)

(when (setq objnum (dun-objnum-from-args-std obj))

(dun-mprincl "You don't have that.")

(progn

(dun-remove-obj-from-inven objnum)

(vector (progn (goto-char alignto) (current-column)))))))

(defun c-lineup-dont-change (langelem)

"Do not change the indentation of the current line.

(t nil)))))

(setq pos (point))

(goto-char pos)

;; Checks to do on all sexps before the brace, up to the

;; beginning of the statement.

; languages where

; `c-opt-inexpr-brace-list-key' is

; non-nil and we have macros.

)))

(defun c-inside-bracelist-p (containing-sexp paren-state)

(c-at-statement-start-p))

(make-obsolete 'c-looking-at-bos 'c-at-statement-start-p "22.1")

(defun c-looking-at-inexpr-block (lim containing-sexp &optional check-at-end)

;; Return non-nil if we're looking at the beginning of a block

;; inside an expression. The value returned is actually a cons of

(and (c-major-mode-is 'c++-mode)

(save-excursion

(goto-char block-follows)

nil

(cons 'inexpr-statement (point)))))

syntax-extra-args

stop-at-boi-only

containing-sexp

;; Add the indicated SYNTAX-SYMBOL to `c-syntactic-context', extending it as

;; needed with further syntax elements of the types `substatement',

;;

;;

;; Point is assumed to be at the prospective anchor point for the

;; given SYNTAX-SYMBOL. More syntax entries are added if we need to

(let ((syntax-last c-syntactic-context)

(boi (c-point 'boi))

;; Set when we're on a label, so that we don't stop there.

;; FIXME: To be complete we should check if we're on a label

;; now at the start.

(c-add-syntax 'substatement nil))))

)))

;; Now we have to go out of this block.

(goto-char containing-sexp)

(cdr (assoc (match-string 1)

c-other-decl-block-key-in-symbols-alist))

(max (c-point 'boi paren-pos) (point))))

(t (c-add-syntax 'defun-block-intro nil))))

(c-add-syntax 'statement-block-intro nil)))

(setq q (cdr (car p))) ; e.g. (nil 28) [from (arglist-cont-nonempty nil 28)]

(while q

(unless (car q)

(setq q (cdr q)))

(setq p (cdr p))))

)))

(c-forward-syntactic-ws (c-point 'eol))

(c-looking-at-special-brace-list (point)))))

(c-add-syntax 'brace-entry-open (point))

))

))))

;;

;; Note that topmost-intro always has an anchor position at bol, for

;; historical reasons. It's often used together with other symbols

;; found anchor position, we rely on that these other symbols always

;; precede topmost-intro in the LANGELEMS list.

;;

(arglist-close . c-lineup-arglist)

(inline-open . 0)

(brace-list-open . +)

(topmost-intro-cont

. (first c-lineup-topmost-intro-cont

c-lineup-gnu-DEFUN-intro-cont))))

;; Anchor pos: At the brace list decl start(*).

(brace-list-intro . +)

;; Anchor pos: At the brace list decl start(*).

;; Anchor pos: At the first non-ws char after the open paren if

;; the first token is on the same line, otherwise boi at that

;; token.

(setq p (line-end-position)))

;; `q' is the point at the end of the block

(hs-forward-sexp mdata 1)

(match-beginning 0)

(point)))

(when (and (< p q) (> (count-lines p q) 1))

(define-key keymap [(control ?c) (control ?j)] #'js-set-js-context)

(define-key keymap [(control meta ?x)] #'js-eval-defun)

(define-key keymap [(meta ?.)] #'js-find-symbol)

["Select New Mozilla Context..." js-set-js-context

(fboundp #'inferior-moz-process)]

["Evaluate Expression in Mozilla Context..." js-eval

nil))))))

(defun js-syntax-propertize (start end)

(goto-char start)

(js-syntax-propertize-regexp end)

(funcall

;;; MozRepl integration

(define-error 'js-moz-bad-rpc "Mozilla RPC Error") ;; '(timeout error))

(defun js--wait-for-matching-output

(process regexp timeout &optional start)

Inside the lexical scope of `with-js', `js?', `js!',

`js-new', `js-eval', `js-list', `js<', `js>', `js-get-service',

`js-create-instance', and `js-qi' are defined."

`(progn

(js--js-enter-repl)

(unwind-protect

(defun js-eval (js)

"Evaluate the JavaScript in JS and return JSON-decoded result."

(with-js

(let* ((content-window (js--js-content-window

(js--get-js-context)))

(eq (cl-fifth window-info) 2))

do (push window-info windows))

for gbrowser = (js< window "gBrowser")

if (js-handle? gbrowser)

(defun js-set-js-context (context)

"Set the JavaScript context to CONTEXT.

When called interactively, prompt for CONTEXT."

(setq js--js-context context))

(defun js--get-js-context ()

(`browser (not (js? (js< (cdr js--js-context)

"contentDocument"))))

(x (error "Unmatched case in js--get-js-context: %S" x))))

js--js-context))

(defun js--js-content-window (context)

comment-start-skip "\\(//+\\|/\\*+\\)\\s *")

(setq-local comment-line-break-function #'c-indent-new-comment-line)

(setq-local c-block-comment-start-regexp "/\\*")

(setq-local electric-indent-chars

(append "{}():;," electric-indent-chars)) ;FIXME: js2-mode adds "[]*".

(let ((dedenter-pos (python-info-dedenter-statement-p)))

(when dedenter-pos

(goto-char dedenter-pos)

("else" "if" "elif" "except" "for" "while")

("except" "except" "try")

("finally" "else" "except" "try")))

(let ((indentation (current-indentation)))

(when (and (not (memq indentation collected-indentations))

(or (not collected-indentations)

(setq collected-indentations

(cons indentation collected-indentations))

(when (member (match-string-no-properties 0)

;; Iterate until we've moved the desired number of stmt ends

(while (not (= (cl-signum arg) 0))

;; if we're looking at the terminator, jump by 2

(and (< 0 arg) (looking-at term)))

(setq n 2)

(setq n 1))

;;; Code:

;; Emacs 21+ handling

(defconst vhdl-emacs-21 (and (<= 21 emacs-major-version) (not (featurep 'xemacs)))

"Non-nil if GNU Emacs 21, 22, ... is used.")

(vhdl-scan-directory-contents dir-name project nil

(format "(%s/%s) " act-dir num-dir)

(cdr dir-list))

(setq dir-list (cdr dir-list)

act-dir (1+ act-dir)))

(vhdl-aput 'vhdl-directory-alist project (list (nreverse dir-list-tmp)))

(if (or (member constant-name single-list)

(member constant-name multi-list))

(progn (setq single-list (delete constant-name single-list))

(unless (match-string 1)

(setq generic-alist (cdr generic-alist)))

(vhdl-forward-syntactic-ws))

(member signal-name multi-out-list))

(setq single-out-list (delete signal-name single-out-list))

(setq multi-out-list (delete signal-name multi-out-list))

((member signal-name single-in-list)

(setq single-in-list (delete signal-name single-in-list))

((not (member signal-name multi-in-list))

;; output signal

(cond

((member signal-name local-list)

(member signal-name multi-in-list))

(setq single-in-list (delete signal-name single-in-list))

(setq multi-in-list (delete signal-name multi-in-list))

((member signal-name single-out-list)

(setq single-out-list (delete signal-name single-out-list))

((not (member signal-name multi-out-list))

(unless (match-string 1)

(setq port-alist (cdr port-alist)))

(vhdl-forward-syntactic-ws))

(push (list inst-name (nreverse constant-alist)

;; prepare signal insertion

(vhdl-goto-marker arch-decl-pos)

(forward-line 1)

generic-end-pos

(vhdl-compose-insert-generic constant-entry)))

(setq generic-pos (point-marker))

(t

(vhdl-goto-marker

(vhdl-max-marker generic-inst-pos generic-pos))

(setq generic-end-pos

(vhdl-compose-insert-generic constant-entry))

(setq generic-inst-pos (point-marker))

(setq constant-alist (cdr constant-alist)))

(when (/= constant-temp-pos generic-inst-pos)

(vhdl-goto-marker (vhdl-max-marker constant-temp-pos generic-pos))

(vhdl-max-marker

port-end-pos (vhdl-compose-insert-port signal-entry)))

(setq port-in-pos (point-marker))

((member signal-name multi-out-list)

(vhdl-goto-marker (vhdl-max-marker port-out-pos port-in-pos))

(setq port-end-pos

(vhdl-max-marker

port-end-pos (vhdl-compose-insert-port signal-entry)))

(setq port-out-pos (point-marker))

((or (member signal-name single-in-list)

(member signal-name single-out-list))

(vhdl-goto-marker

(vhdl-max-marker port-out-pos port-in-pos)))

(setq port-end-pos (vhdl-compose-insert-port signal-entry))

(setq port-inst-pos (point-marker))

((equal (upcase (nth 2 signal-entry)) "OUT")

(vhdl-goto-marker signal-pos)

(vhdl-compose-insert-signal signal-entry)

(setq signal-pos (point-marker))

(setq signal-alist (cdr signal-alist)))

(when (/= port-temp-pos port-inst-pos)

(vhdl-goto-marker

"Remove duplicate elements from IN-LIST."

(let (out-list)

(while in-list

(setq in-list (cdr in-list)))

out-list))

(grep-compute-defaults)

(defvar grep-find-template)

(defvar grep-highlight-matches)

grep-find-template t t))

(grep-highlight-matches nil)

(command (xref--rgrep-command (xref--regexp-to-extended regexp)

recentf-mode

(recentf-load-list)))))

"Mode bits of recentf save file, as an integer, or nil.

If non-nil, after writing `recentf-save-file', set its mode bits to

this value. By default give R/W access only to the user who owns that

:type 'face

:group 'matching)

(defcustom list-matching-lines-prefix-face 'shadow

"Face used by \\[list-matching-lines] to show the prefix column.

If the face doesn't differ from the default face,

"*")

(or unique-p (not interactive-p)))))

"Show all lines in the current buffer containing a match for REGEXP.

If a match spreads across multiple lines, all those lines are shown.

NLINES defaults to `list-matching-lines-default-context-lines'.

Interactively it is the prefix arg.

The lines are shown in a buffer named `*Occur*'.

It serves as a menu to find any of the occurrences in this buffer.

\\<occur-mode-map>\\[describe-mode] in that buffer will explain how.

If REGEXP contains upper case characters (excluding those preceded by `\\')

and `search-upper-case' is non-nil, the matching is case-sensitive.

program. When there is no parenthesized subexpressions in REGEXP

the entire match is collected. In any case the searched buffer

is not modified."

(defvar ido-ignore-item-temp-list)

(occur-mode))

(let ((inhibit-read-only t)

;; Don't generate undo entries for creation of the initial contents.

(erase-buffer)

(let ((count

(if (stringp nlines)

(if (= count 0)

(kill-buffer occur-buf)

(display-buffer occur-buf)

(setq next-error-last-buffer occur-buf)

(setq buffer-read-only t)

(set-buffer-modified-p nil)

(let ((global-lines 0) ;; total count of matching lines

(global-matches 0) ;; total count of matches

(coding nil)

;; Map over all the buffers

(dolist (buf buffers)

(when (buffer-live-p buf)

(let ((lines 0) ;; count of matching lines

(matches 0) ;; count of matches

(prev-line nil) ;; line number of prev match endpt

(prev-after-lines nil) ;; context lines of prev match

(matchbeg 0)

(origpt nil)

(begpt nil)

(endpt nil)

(marker nil)

(curstring "")

(ret nil)

(nth 0 ret))))

;; Actually insert the match display data

(with-current-buffer out-buf

(insert data)))

(goto-char endpt))

(if endpt

(forward-line 1))

(goto-char (point-max)))

(setq prev-line (1- curr-line)))

;; Flush remaining context after-lines.

(when prev-after-lines

(with-current-buffer out-buf

(let ((beg (point))

end)

(insert (propertize

matches (if (= matches 1) "" "es")

;; Don't display the same number of lines

;; and matches in case of 1 match per line.

;; Don't display regexp for multi-buffer.

(if (> (length buffers) 1)

"" (occur-regexp-descr regexp))

'read-only t))

(setq end (point))

(add-text-properties beg end `(occur-title ,buf))

(when title-face

;; Display total match count and regexp for multi-buffer.

(when (and (not (zerop global-lines)) (> (length buffers) 1))

(goto-char (point-min))

buffer."

(setq comint-prompt-regexp shell-prompt-pattern)

(shell-completion-vars)

(shell-dirtrack-mode 1)

;; By default, ansi-color applies faces using overlays. This is

;; region is active when there's no mark.

(progn (cl-assert (mark)) t)))

(defun region-noncontiguous-p ()

"Return non-nil if the region contains several pieces.

An example is a rectangular region handled as a list of

separate contiguous regions for each line."

(defvar redisplay-unhighlight-region-function

(lambda (rol) (when (overlayp rol) (delete-overlay rol))))



;; This executes C-g typed while Emacs is waiting for a command.

;; Quitting out of a program does not go through here;

(defun keyboard-quit ()

"Signal a `quit' condition.

During execution of Lisp code, this character causes a quit directly.

(declare (compiler-macro internal--compiler-macro-cXXr))

(cdr (cdr x)))

(defun last (list &optional n)

"Return the last link of LIST. Its car is the last element.

If LIST is nil, return nil.

;; bug#23850

(make-obsolete 'string-to-unibyte "use `encode-coding-string'." "26.1")

(make-obsolete 'string-as-unibyte "use `encode-coding-string'." "26.1")

(make-obsolete 'string-to-multibyte "use `decode-coding-string'." "26.1")

(make-obsolete 'string-as-multibyte "use `decode-coding-string'." "26.1")

(defun log10 (x)

"Return (log X 10), the log base 10 of X."

((eq char ?\017)) ; Shift In - ignored

((eq char ?\^G) ;; (terminfo: bel)

(beep t))

(let ((end (string-match "\r?\n" str i)))

(if end

(setq term-terminal-parameter (substring str i))

(setq term-terminal-state 4)

(setq i str-length))))

;;; Code:

(require 'seq)

(require 'sgml-mode)

(require 'smie)

(defgroup css nil

"Cascading Style Sheets (CSS) editing mode."

(modify-syntax-entry ?- "_" st)

st))

(eval-and-compile

(defconst css--uri-re

(concat

(defconst css-smie-grammar

(smie-prec2->grammar

(defun css-smie--forward-token ()

(cond

";")

((progn (forward-comment (point-max))

(looking-at "[;,:]"))

(t (smie-default-forward-token))))

(defun css-smie--backward-token ()

((and (eq (char-before) ?\}) (scss-smie--not-interpolation-p)

(> pos (point))) ";")

((memq (char-before) '(?\; ?\, ?\:))

(t (smie-default-backward-token)))))

(defun css-smie-rules (kind token)

(setq-local font-lock-defaults

(list (scss-font-lock-keywords) nil t)))

(provide 'css-mode)

;;; css-mode.el ends here

(?U . "\\autocite*[][]{%l}")

(?a . "\\citeauthor{%l}")

(?A . "\\citeauthor*{%l}")

(?y . "\\citeyear{%l}")

(?Y . "\\citeyear*{%l}")

(?n . "\\nocite{%l}")))

(defconst diff-hunk-header-re

(concat "^\\(?:" diff-hunk-header-re-unified ".*\\|\\*\\{15\\}.*\n\\*\\*\\* .+ \\*\\*\\*\\*\\|[0-9]+\\(,[0-9]+\\)?[acd][0-9]+\\(,[0-9]+\\)?\\)$"))

(defconst diff-file-header-re (concat "^\\(--- .+\n\\+\\+\\+ \\|\\*\\*\\* .+\n--- \\|[^-+!<>0-9@* \n]\\).+\n" (substring diff-hunk-header-re 1)))

(defvar diff-narrowed-to nil)

(defun diff-hunk-style (&optional style)

;; "index ", "old mode", "new mode", "new file mode" and

;; "deleted file mode" are output by git-diff.

(defconst diff-file-junk-re

;; If point is in a diff header, then return beginning

;; of hunk position otherwise return nil.

(error "Can't find the beginning of the hunk")))

((re-search-backward regexp nil t)) ; In the middle of a hunk.

((re-search-forward regexp nil t) ; At first hunk header.

(t (error "Can't find the beginning of the hunk"))))))

(defun diff-unified-hunk-p ()

(if arg (diff-bounds-of-file) (diff-bounds-of-hunk)))

(set (make-local-variable 'diff-narrowed-to) (if arg 'file 'hunk)))

(defun diff-hunk-kill ()

"Kill the hunk at point."

(interactive)

(defun diff-beginning-of-file-and-junk ()

"Go to the beginning of file-related diff-info.

(defun diff-file-kill ()

"Kill current file's hunks."

(interactive)

(defun diff-kill-junk ()

"Kill spurious empty diffs."

(pcase (char-after)

(?\s (cl-decf before) (cl-decf after) t)

(?-

(?+ (cl-decf after) t)

(_

(cond

"Highlight changes of hunk at point at a finer granularity."

(interactive)

(require 'smerge-mode)

(defun diff-undo (&optional arg)

"Perform `undo', ignoring the buffer's read-only status."

(defsubst ediff-get-symbol-from-alist (buf-type alist)

(cdr (assoc buf-type alist)))

(defconst ediff-difference-vector-alist

'((A . ediff-difference-vector-A)

(B . ediff-difference-vector-B)

;;buffer-read-only

mode-line-format))

;; [ status status status ...]

;; Each status: [state-of-merge state-of-ancestor]

;; state-of-merge is default-A, default-B, prefer-A, or prefer-B. It

(defun xml-parse-attlist (&optional xml-ns)

"Return the attribute-list after point.

Leave point at the first non-blank character after the tag."

(skip-syntax-forward " ")

(while (looking-at (eval-when-compile

(concat "\\(" xml-name-re "\\)\\s-*=\\s-*")))

DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,

doc: /* Return a newly created list of length LENGTH, with each element being INIT. */)

{

CHECK_NATNUM (length);

{

val = Fcons (init, val);

}

return val;

}

}

static bool setjmp_tested_p;

static int longjmps_done;

\n\

Emacs garbage collector has been changed to use conservative stack\n\

marking. Emacs has determined that the method it uses to do the\n\

Please mail the result to <emacs-devel@gnu.org>.\n\

"

\n\

Emacs garbage collector has been changed to use conservative stack\n\

marking. Emacs has determined that the default method it uses to do the\n\

static void

test_setjmp (void)

{

char buf[10];

register int x;

sys_jmp_buf jbuf;

if (longjmps_done == 1)

sys_longjmp (jbuf, 1);

}

/* Mark live Lisp objects on the C stack.

We have to mark Lisp objects in CPU registers that can hold local

variables or are used to pass parameters.

to see in a jmp_buf which itself lies on the stack. This doesn't

have to be true! It must be verified for each system, possibly

by taking a look at the source code of setjmp.

{

void *end;

struct thread_state *self = current_thread;

self->stack_top = end;

eassert (current_thread == self);

}

return new;

}

DEFUN ("purecopy", Fpurecopy, Spurecopy, 1, 1, 0,

doc: /* Make a copy of object OBJ in pure storage.

Recursively copies contents of vectors and cons cells.

{

if (NILP (Vpurify_flag))

return obj;

/* Can't purify those. */

return obj;

else

return purecopy (obj);

}

static Lisp_Object

purecopy (Lisp_Object obj)

{

obj = make_pure_string (SSDATA (obj), SCHARS (obj),

SBYTES (obj),

STRING_MULTIBYTE (obj));

{

struct Lisp_Vector *objp = XVECTOR (obj);

ptrdiff_t nbytes = vector_nbytes (objp);

}

static void

mark_pinned_symbols (void)

{

struct symbol_block *sblk;

for (i = 0; i < staticidx; i++)

mark_object (*staticvec[i]);

mark_pinned_symbols ();

mark_terminals ();

mark_kboards ();

(void)

{

void *end;

return garbage_collect_1 (end);

}

void

init_alloc (void)

{