;; Author: Carsten Dominik <carsten at orgmode dot org>

;; Keywords: outlines, hypermedia, calendar, wp

;; Homepage: https://orgmode.org

;;

;; This file is part of GNU Emacs.

;;

;;; Code:

(defvar org-inhibit-highlight-removal nil) ; dynamically scoped param

;;;; Require other packages

(message "You need to run \"make\" or \"make autoloads\" from Org lisp directory")

(sit-for 3))))

(require 'org-compat)

;; `org-outline-regexp' ought to be a defconst but is let-bound in

;; some places -- e.g. see the macro `org-with-limited-levels'.

(defvar org-outline-regexp "\\*+ "

"Regexp to match Org headlines.")

(declare-function calendar-check-holidays "holidays" (date))

(declare-function cdlatex-environment "ext:cdlatex" (environment item))

(declare-function isearch-no-upper-case-p "isearch" (string regexp-flag))

(declare-function org-add-archive-files "org-archive" (files))

(declare-function org-agenda-entry-get-agenda-timestamp "org-agenda" (pom))

(declare-function org-agenda-list "org-agenda" (&optional arg start-day span with-hour))

(declare-function org-agenda-redo "org-agenda" (&optional all))

(declare-function org-babel-do-in-edit-buffer "ob-core" (&rest body) t)

(declare-function org-babel-tangle-file "ob-tangle" (file &optional target-file lang))

(declare-function org-beamer-mode "ox-beamer" (&optional prefix) t)

(declare-function org-clock-get-last-clock-out-time "org-clock" ())

(declare-function org-clock-out "org-clock" (&optional switch-to-state fail-quietly at-time))

(declare-function org-clock-remove-overlays "org-clock" (&optional beg end noremove))

(declare-function org-clock-sum "org-clock" (&optional tstart tend headline-filter propname))

(declare-function org-clock-sum-current-item "org-clock" (&optional tstart))

(declare-function org-clock-timestamps-down "org-clock" (&optional n))

(declare-function org-clock-update-time-maybe "org-clock" ())

(declare-function org-clocking-buffer "org-clock" ())

(declare-function org-clocktable-shift "org-clock" (dir n))

(declare-function org-element-at-point "org-element" ())

(declare-function org-element-cache-refresh "org-element" (pos))

(declare-function org-element-cache-reset "org-element" (&optional all))

(declare-function org-element-contents "org-element" (element))

(declare-function org-element-context "org-element" (&optional element))

(declare-function org-element-copy "org-element" (datum))

(declare-function org-element-interpret-data "org-element" (data))

(declare-function org-element-lineage "org-element" (blob &optional types with-self))

(declare-function org-element-link-parser "org-element" ())

(declare-function org-element-property "org-element" (property element))

(declare-function org-element-put-property "org-element" (element property value))

(declare-function org-element-swap-A-B "org-element" (elem-a elem-b))

(declare-function org-element-type "org-element" (element))

(declare-function org-id-find-id-file "org-id" (id))

(declare-function org-id-get-create "org-id" (&optional force))

(declare-function org-inlinetask-at-task-p "org-inlinetask" ())

(declare-function org-inlinetask-outline-regexp "org-inlinetask" ())

(declare-function org-inlinetask-toggle-visibility "org-inlinetask" ())

(declare-function org-plot/gnuplot "org-plot" (&optional params))

(declare-function org-tags-view "org-agenda" (&optional todo-only match))

(defvar ffap-url-regexp)

(defvar org-element-paragraph-separate)

;; load languages based on value of `org-babel-load-languages'

(defvar org-babel-load-languages)

(let ((active (cdr pair)) (lang (symbol-name (car pair))))

(if active

(require (intern (concat "ob-" lang)))

;;;###autoload

(defun org-babel-load-file (file &optional compile)

"Load Emacs Lisp source code blocks in the Org FILE.

This function exports the source code using `org-babel-tangle'

(interactive "fFile to load: \nP")

(defcustom org-babel-load-languages '((emacs-lisp . t))

"Languages which can be evaluated in Org buffers.

This list can be used to load support for any of the languages

:group 'org-babel

:set 'org-babel-do-load-languages

:version "24.1"

An archived subtree does not open during visibility cycling, and does

not contribute to the agenda listings.")

(eval-and-compile

(defconst org-comment-string "COMMENT"

"Entries starting with this keyword will never be exported.

"The property that is being used to keep track of effort estimates.

Effort estimates given in this property need to have the format H:MM.")

;;;; Timestamp

(defconst org-ts-regexp "<\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} ?[^\r\n>]*?\\)>"

The time stamps may be either active or inactive.")

(defconst org-repeat-re

"Regular expression for specifying repeated events.

After a match, group 1 contains the repeat expression.")

(org-load-modules-maybe 'force)

(org-element-cache-reset 'all)))

"Modules that should always be loaded together with org.el.

If a description starts with <C>, the file is not part of Emacs

For export specific modules, see also `org-export-backends'."

:group 'org

:set 'org-set-modules

:type

'(set :greedy t

(const :tag " crypt: Encryption of subtrees" org-crypt)

(const :tag " ctags: Access to Emacs tags with links" org-ctags)

(const :tag " habit: Track your consistency with habits" org-habit)

(const :tag " id: Global IDs for identifying entries" org-id)

(const :tag " inlinetask: Tasks independent of outline hierarchy" org-inlinetask)

(const :tag " mouse: Additional mouse support" org-mouse)

(const :tag " protocol: Intercept calls from emacsclient" org-protocol)

(const :tag "C checklist: Extra functions for checklists in repeated tasks" org-checklist)

(const :tag "C choose: Use TODO keywords to mark decisions states" org-choose)

(const :tag "C collector: Collect properties into tables" org-collector)

(const :tag "C depend: TODO dependencies for Org mode\n\t\t\t(PARTIALLY OBSOLETE, see built-in dependency support))" org-depend)

(const :tag "C eval-light: Evaluate inbuffer-code on demand" org-eval-light)

(const :tag "C eval: Include command output as text" org-eval)

(const :tag "C expiry: Expiry mechanism for Org entries" org-expiry)

(const :tag "C interactive-query: Interactive modification of tags query\n\t\t\t(PARTIALLY OBSOLETE, see secondary filtering)" org-interactive-query)

(const :tag "C invoice: Help manage client invoices in Org mode" org-invoice)

(const :tag "C learn: SuperMemo's incremental learning algorithm" org-learn)

(const :tag "C mac-link: Grab links and url from various mac Applications" org-mac-link)

(const :tag "C mairix: Hook mairix search into Org for different MUAs" org-mairix)

(const :tag "C panel: Simple routines for us with bad memory" org-panel)

(const :tag "C registry: A registry for Org links" org-registry)

(const :tag "C secretary: Team management with Org" org-secretary)

(const :tag "C sqlinsert: Convert Org tables to SQL insertions" orgtbl-sqlinsert)

(const :tag "C toc: Table of contents for Org buffer" org-toc)

(const :tag "C track: Keep up with Org mode development" org-track)

(const :tag "C velocity Something like Notational Velocity for Org" org-velocity)

(const :tag "C wikinodes: CamelCase wiki-like links" org-wikinodes)

(repeat :tag "External packages" :inline t (symbol :tag "Package"))))

(defvar org-export-registered-backends) ; From ox.el.

a tags/property/todo match as it is used in the agenda tags view.

The list of commands is: `org-schedule', `org-deadline',

`org-archive-to-archive-sibling'. The archiving commands skip

already archived entries."

:type '(choice (const :tag "Don't loop" nil)

:group 'org-todo

:group 'org-archive)

(defcustom org-startup-folded t

"Non-nil means entering Org mode will switch to OVERVIEW.

(defcustom org-startup-align-all-tables nil

"Non-nil means align all tables when visiting a file.

This can also be configured on a per-file basis by adding one of

the following lines anywhere in the buffer:

#+STARTUP: align

:group 'org-startup

:type 'boolean)

(defcustom org-startup-with-inline-images nil

"Non-nil means show inline images when loading a new Org file.

This can also be configured on a per-file basis by adding one of

:group 'org-startup

:type 'boolean)

(defcustom org-ellipsis nil

"The ellipsis to use in the Org mode outline.

(const :tag "Each time a new frame" new-frame)

(const :tag "One dedicated frame" dedicated-frame)))

(defcustom org-bookmark-names-plist

'(:last-capture "org-capture-last-stored"

:type 'hook)

(defcustom org-cycle-hook '(org-cycle-hide-archived-subtrees

org-cycle-show-empty-lines

org-optimize-window-after-visibility-change)

"Hook that is run after `org-cycle' has changed the buffer visibility.

a headline will be indented when this variable is set.

Note that this is all about true indentation, by adding and

level-dependent indentation in a virtual way, i.e. at display

time in Emacs."

:group 'org-edit-structure

(defvaralias 'org-special-ctrl-a 'org-special-ctrl-a/e)

:group 'org-edit-structure

:type 'hook)

(defgroup org-sparse-trees nil

"Options concerning sparse trees in Org mode."

:tag "Org Sparse Trees"

Such highlights are created by `org-occur' and `org-clock-display'.

When nil, `\\[org-ctrl-c-ctrl-c]' needs to be used \

to get rid of the highlights.

:group 'org-sparse-trees

:group 'org-time

:type 'boolean)

:group 'org-sparse-trees

:type 'hook)

(defcustom org-self-insert-cluster-for-undo nil

"Non-nil means cluster self-insert commands for undo when possible.

If this is set, then, like in the Emacs command loop, 20 consecutive

:group 'org-table

:type 'boolean)

(defvaralias 'org-activate-links 'org-highlight-links)

(defcustom org-highlight-links '(bracket angle plain radio tag date footnote)

"Types of links that should be highlighted in Org files.

If you set this variable during an Emacs session, use `org-mode-restart'

in the Org buffer so that the change takes effect."

:group 'org-appearance

:type '(set :greedy t

(const :tag "Double bracket links" bracket)

(const :tag "Timestamps" date)

(const :tag "Footnotes" footnote)))

(defcustom org-mark-ring-length 4

"Number of different positions to be recorded in the ring.

Changing this requires a restart of Emacs to work correctly."

:group 'org-link-follow

:type 'integer)

(defgroup org-refile nil

"Options concerning refiling entries in Org mode."

:tag "Org Refile"

:group 'org-capture

:type 'file)

(defcustom org-reverse-note-order nil

"Non-nil means store new notes at the beginning of a file or entry.

When nil, new notes will be filed to the end of a file or entry.

You can have local logging settings for a subtree by setting the LOGGING

property to one or more of these keywords.

:group 'org-refile

:group 'org-progress

:version "24.1"

:type '(choice (const sequence)

(const type)))

"\\<org-mode-map>\

Non-nil means use the fast todo selection scheme with `\\[org-todo]'.

This variable describes if and under what circumstances the cycling

mechanism for TODO keywords will be replaced by a single-key, direct

In all cases, the special interface is only used if access keys have

actually been assigned by the user, i.e. if keywords in the configuration

are followed by a letter in parenthesis, like TODO(t)."

:group 'org-todo

:type '(choice

(const :tag "Never" nil)

(defcustom org-provide-todo-statistics t

"Non-nil means update todo statistics after insert and toggle.

entry can be switched to DONE.

This variable needs to be set before org.el is loaded, and you need to

restart Emacs after a change to make the change effective. The only way

:set (lambda (var val)

(set var val)

(if val

(setq org-log-done 'note)))

(defcustom org-log-reschedule nil

Possible values are:

#+STARTUP: nologreschedule

#+STARTUP: logreschedule

:group 'org-todo

:group 'org-progress

:type '(choice

(const :tag "No logging" nil)

(const :tag "Record timestamp" time)

(defcustom org-log-redeadline nil

Possible values are:

#+STARTUP: lognoteredeadline

You can have local logging settings for a subtree by setting the LOGGING

:group 'org-todo

:group 'org-progress

:type '(choice

(defcustom org-todo-repeat-to-state nil

"The TODO state to which a repeater should return the repeating task.

:group 'org-todo

:version "24.1"

(defcustom org-log-repeat 'time

"Non-nil means record moving through the DONE state when triggering repeat.

(const :tag "Force recording the DONE state" time)

(const :tag "Force recording a note with the DONE state" note)))

(defgroup org-priorities nil

"Priorities in Org mode."

be represented with the type used internally to represent time.

Dates between 1970-1-1 and 2038-1-1 can always be represented

correctly. Some systems allow for earlier dates, some for later,

Org buffer, putting the cursor on the year and hitting S-up and

S-down to test the range.

you specify dates outside the 1970-2037 range, so it is certain that

these dates will work in whatever version of Emacs you are

running, and also that you can move a file from one Emacs implementation

a message and beep.

When this variable is nil, Org will check if the date is

where TAG is a tag as a string, SELECT is character, used to

select that tag through the fast tag selection interface, and

SPECIAL is one of the following keywords: `:startgroup',

`:newline'. These keywords are used to define a hierarchy of

tags. See manual for details.

where TAG is a tag as a string, SELECT is a character, used to

select that tag through the fast tag selection interface, and

SPECIAL is one of the following keywords: `:startgroup',

`:newline'. These keywords are used to define a hierarchy of

tags. See manual for details.

(defcustom org-complete-tags-always-offer-all-agenda-tags nil

"If non-nil, always offer completion for all tags of all agenda files.

(add-hook \\='org-capture-mode-hook

(lambda ()

:group 'org-tags

:type '(choice

(const :tag "No sorting" nil)

(function :tag "Custom function" nil)))

(defvar org-tags-history nil

:group 'org-properties

:type 'string)

(defcustom org-columns-ellipses ".."

"The ellipses to be used when a field in column view is truncated.

When this is the empty string, as many characters as possible are shown,

:group 'org-agenda

:type 'boolean)

(defcustom org-agenda-diary-file 'diary-file

"File to which to add new entries with the `i' key in agenda and calendar.

When this is the symbol `diary-file', the functionality in the Emacs

(const :tag "The standard Emacs diary file" diary-file)

(file :tag "Special Org file diary entries")))

(defgroup org-latex nil

"Options for embedding LaTeX code into Org mode."

:tag "Org LaTeX"

:image-output-type "png"

:image-size-adjust (1.0 . 1.0)

:latex-compiler ("latex -interaction nonstopmode -output-directory %o %f")

(dvisvgm

:programs ("latex" "dvisvgm")

:description "dvi > svg"

:message "you need to install the programs: latex and dvisvgm."

:image-input-type "dvi"

:image-output-type "svg"

:image-size-adjust (1.7 . 1.5)

:programs ("latex" "convert")

:description "pdf > png"

:message "you need to install the programs: latex and imagemagick."

:image-input-type "pdf"

:image-output-type "png"

:image-size-adjust (1.0 . 1.0)

:message string, message it when required programs cannot be found.

:image-input-type string, input file type of image converter (e.g., \"dvi\").

:image-output-type string, output file type of image converter (e.g., \"png\").

:image-size-adjust cons of numbers, the car element is used to adjust LaTeX

image size showed in buffer and the cdr element is for

HTML file. This option is only useful for process

Place-holders only used by `:image-converter':

%D dpi, which is used to adjust image size by some processing commands.

%S the image size scale ratio, which is used to adjust image size by some

processing commands."

If SNIPPET-FLAG is non-nil, the package also needs to be included

when compiling LaTeX snippets into images for inclusion into

A string will be inserted as-is in the header of the document."

:group 'org-latex

A cell is of the format:

SNIPPET-FLAG, when non-nil, indicates that this package is also

needed when turning LaTeX snippets into images for inclusion into

non-LaTeX output.

A string will be inserted as-is in the header of the document.

Make sure that you only list packages here which:

:group 'org-appearance

:type 'boolean)

(defcustom org-highlight-latex-and-related nil

"Non-nil means highlight LaTeX related syntax in the buffer.

When non-nil, the value should be a list containing any of the

following symbols:

`latex' Highlight LaTeX snippets and environments.

`script' Highlight subscript and superscript.

`entities' Highlight entities."

:type '(choice

(const :tag "No highlighting" nil)

(set :greedy t :tag "Highlight"

(const :tag "LaTeX snippets and environments" latex)

(const :tag "Subscript and superscript" script)

(const :tag "Entities" entities))))

(defcustom org-hide-emphasis-markers nil

"Non-nil mean font-lock should hide the emphasis marker characters."

:group 'org-appearance

(defcustom org-hide-macro-markers nil

"Non-nil mean font-lock should hide the brackets marking macro calls."

;; set this option proved cumbersome. See this message/thread:

;; http://article.gmane.org/gmane.emacs.orgmode/68681

(defvar org-emphasis-regexp-components

"Components used to build the regular expression for emphasis.

This is a list with five entries. Terminology: In an emphasis string

like \" *strong word* \", we call the initial space PREMATCH, the final

non-shy groups here, and don't allow newline here.

newline The maximum number of newlines allowed in an emphasis exp.

(defcustom org-emphasis-alist

'(("*" bold)

"org-agenda"

(extra txt &optional level category tags dotime

remove-re habitp))

(declare-function org-agenda-new-marker "org-agenda" (&optional pos))

(declare-function org-agenda-save-markers-for-cut-and-paste

"org-agenda"

(beg end))

(declare-function org-agenda-set-restriction-lock "org-agenda" (&optional type))

(declare-function org-agenda-skip "org-agenda" ())

(declare-function org-gnus-follow-link "org-gnus" (&optional group article))

(declare-function org-indent-mode "org-indent" (&optional arg))

(declare-function org-inlinetask-goto-beginning "org-inlinetask" ())

(declare-function org-inlinetask-goto-end "org-inlinetask" ())

(declare-function org-inlinetask-in-task-p "org-inlinetask" ())

(declare-function org-inlinetask-remove-END-maybe "org-inlinetask" ())

(declare-function parse-time-string "parse-time" (string))

(defvar align-mode-rules-list)

(defvar calc-embedded-close-formula)

(defvar remember-data-file)

(defvar texmathp-why)

(declare-function org-clock-save-markers-for-cut-and-paste "org-clock" (beg end))

(declare-function org-resolve-clocks "org-clock"

(&optional also-non-dangling-p prompt last-valid))

(defvar org-clock-start-time)

(defvar org-clock-marker (make-marker)

"Marker recording the last clock-in.")

;; Include headline point is currently on.

(beginning-of-line)

(while (and (< (point) end) (re-search-forward re end t))

(org-flag-subtree t)

(org-end-of-subtree t))))))

(defun org-flag-subtree (flag)

(save-excursion

(org-back-to-heading t)

(defalias 'org-advertized-archive-subtree 'org-archive-subtree)

("oddeven" org-odd-levels-only nil)

("align" org-startup-align-all-tables t)

("noalign" org-startup-align-all-tables nil)

("inlineimages" org-startup-with-inline-images t)

("noinlineimages" org-startup-with-inline-images nil)

("latexpreview" org-startup-with-latex-preview t)

(message "Groups tags support has been turned %s"

(if org-group-tags "on" "off")))

(cond

((null alist2) alist1)

((null alist1) alist2)

(defun org-set-regexps-and-options (&optional tags-only)

"Precompute regular expressions used in the current buffer.

(mapcar #'org-add-prop-inherited

(cdr (assq 'filetags alist))))

(setq org-current-tag-alist

org-tag-persistent-alist

(let ((tags (cdr (assq 'tags alist))))

(if tags (org-tag-string-to-alist tags)

((equal key "SETUPFILE")

(unless buffer-read-only ; Do not check in Gnus messages.

(let ((f (and (org-string-nw-p value)

(when (and f (file-readable-p f) (not (member f files)))

(with-temp-buffer

(setq default-directory (file-name-directory f))

`org-tag-alist-to-string'. Return value is an alist suitable for

`org-tag-alist' or `org-tag-persistent-alist'."

(let ((lines (mapcar #'split-string (split-string s "\n" t)))

"\\(?:(\\(.\\))\\)?\\'"))

alist group-flag)

(dolist (tokens lines (cdr (nreverse alist)))

;;;; Define the Org mode

(defun org-before-change-function (_beg _end)

"Every change indicates that a table might need an update."

(setq org-table-may-need-update t))

(defvar org-agenda-keep-modes nil) ; Dynamically-scoped param.

(defvar org-inhibit-logging nil) ; Dynamically-scoped param.

(defvar org-inhibit-blocking nil) ; Dynamically-scoped param.

(defvar bidi-paragraph-direction)

(defvar buffer-face-mode-face)

The following commands are available:

\\{org-mode-map}"

(org-load-modules-maybe)

(org-install-agenda-files-menu)

(add-to-invisibility-spec '(org-hide-block . t))

(setq-local outline-regexp org-outline-regexp)

(setq-local outline-level 'org-outline-level)

(setq bidi-paragraph-direction 'left-to-right)

;; Calc embedded

(setq-local calc-embedded-open-mode "# ")

;; Modify a few syntax entries

(modify-syntax-entry ?\" "\"")

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

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

(setq-local font-lock-unfontify-region-function 'org-unfontify-region)

;; Activate before-change-function

(setq-local org-table-may-need-update t)

(forward-char -1))))

;; Next error for sparse trees

(setq-local next-error-function 'org-occur-next-match)

;; Make sure dependence stuff works reliably, even for users who set it

;; too late :-(

(if org-enforce-todo-dependencies

(regexp . "^[ \t]*#\\+[A-Z_]+:\\(\\s-*\\)\\S-+")

(modes . '(org-mode)))))

;; Make isearch reveal context

(setq-local outline-isearch-open-invisible-function

(lambda (&rest _) (org-show-context 'isearch)))

(unless org-inhibit-startup

(org-unmodified

(when org-startup-with-beamer-mode (org-beamer-mode))

(when org-startup-with-inline-images (org-display-inline-images))

(unless org-inhibit-startup-visibility-stuff (org-set-startup-visibility))

(when org-startup-truncated (setq truncate-lines t))

;; Try to set `org-hide' face correctly.

(let ((foreground (org-find-invisible-foreground)))

(when foreground

("8.2.7" . "24.4")

("8.3" . "26.1")

("9.0" . "26.1")

(defvar org-mode-transpose-word-syntax-table

(let ((st (make-syntax-table text-mode-syntax-table)))

(let* ((time (decode-time now))

(res (apply #'encode-time 0 (* r (round (nth 1 time) r))

(nthcdr 2 time))))

res

(defun org-today ()

"Return today date, considering `org-extend-today-until'."

(time-to-days

;;;; Font-Lock stuff, including the activators

(require 'font-lock)

(defconst org-match-sexp-depth 3

"Number of stacked braces for sub/superscript matching.")

"\\(" (org-create-multibrace-regexp "{" "}" org-match-sexp-depth) "\\)")

"The regular expression matching a sub- or superscript, forcing braces.")

(defvar org-emph-face nil)

(defun org-do-emphasis-faces (limit)

(match-beginning 2) (match-end 2) 'face face)

(when verbatim?

(org-remove-flyspell-overlays-in

(add-text-properties (match-beginning 2) (match-end 2)

'(font-lock-multiline t org-emphasis t))

(when org-hide-emphasis-markers

"Add link properties to links.

This includes angle, plain, and bracket links."

(catch :exit

(let* ((start (match-beginning 0))

(end (match-end 0))

(style (cond ((eq ?< (char-after start)) 'angle)

((eq ?\[ (char-after (1+ start))) 'bracket)

(t 'plain))))

(when (and (memq style org-highlight-links)

;; Do not confuse plain links with tags.

(not (and (eq style 'plain)

(let ((face (get-text-property

(append `(invisible

,(or (org-link-get-parameter type :display)

'org-link))

(add-text-properties start visible-start hidden)

(add-text-properties visible-start visible-end properties)

(add-text-properties visible-end end hidden)

"^\\([ \t]*#\\(\\(\\+[a-zA-Z]+:?\\| \\|$\\)\\(_\\([a-zA-Z]+\\)\\)?\\)[ \t]*\\(\\([^ \t\n]*\\)[ \t]*\\(.*\\)\\)\\)"

limit t)

(let ((beg (match-beginning 0))

(dc1 (downcase (match-string 2)))

(dc3 (downcase (match-string 3)))

(cond

((and (match-end 4) (equal dc3 "+begin"))

;; Truly a block

(setq block-type (downcase (match-string 5))

(when (re-search-forward

(concat "^[ \t]*#\\+end" (match-string 4) "\\>.*")

nil t) ;; on purpose, we look further than LIMIT

(when quoting

'(display t invisible t intangible t)))

(add-text-properties

(cond

((and lang (not (string= lang "")) org-src-fontify-natively)

(org-src-font-lock-fontify-block lang block-start block-end)

(quoting

((not org-fontify-quote-and-verse-blocks))

((string= block-type "quote")

(add-face-text-property

((string= block-type "verse")

(add-face-text-property

t))

((member dc1 '("+title:" "+author:" "+email:" "+date:"))

(org-remove-flyspell-overlays-in

'(font-lock-fontified t face org-block))

t)

((member dc3 '(" " ""))

(org-remove-flyspell-overlays-in beg (match-end 0))

(add-text-properties

beg (match-end 0)

"Fontify drawers."

(when (re-search-forward org-drawer-regexp limit t)

(add-text-properties

t))

(defun org-fontify-macros (limit)

(add-text-properties closing-start end '(invisible t)))

t)))))

(defun org-activate-footnote-links (limit)

"Add text properties for footnotes."

(let ((fn (org-footnote-next-reference-or-definition limit)))

(org-display-custom-time (match-beginning 1) (match-end 1)))

t))

(defun org-activate-target-links (limit)

"Add text properties for target matches."

(when org-target-link-regexp

(let ((case-fold-search t))

(when (re-search-forward org-target-link-regexp limit t)

(org-remove-flyspell-overlays-in (match-beginning 1) (match-end 1))

(add-text-properties (match-beginning 1) (match-end 1)

(org-rear-nonsticky-at (match-end 1))

t))))

(defvar org-latex-and-related-regexp nil

"Regular expression for highlighting LaTeX, entities and sub/superscript.")

(defun org-compute-latex-and-related-regexp ()

"Compute regular expression for LaTeX, entities and sub/superscript.

Result depends on variable `org-highlight-latex-and-related'."

"Highlight LaTeX snippets and environments, entities and sub/superscript.

(when (org-string-nw-p org-latex-and-related-regexp)

(catch 'found

(add-text-properties (+ offset (match-beginning 0)) (match-end 0)

'(font-lock-multiline t)))

(throw 'found t)))

(font-lock-mode 1)))

(defun org-activate-tags (limit)

(org-remove-flyspell-overlays-in (match-beginning 1) (match-end 1))

(add-text-properties (match-beginning 1) (match-end 1)

(list 'mouse-face 'highlight

'("^[ \t]*| *\\([#*]\\) *|" (1 'org-formula t))

'("^[ \t]*|\\( *\\([$!_^/]\\) *|.*\\)|" (1 'org-formula t))

'("| *\\(<[lrc]?[0-9]*>\\)" (1 'org-formula t))

;; Properties

(list org-property-re

'(1 'org-special-keyword t)

'(3 'org-property-value t))

;; Link related fontification.

'(org-activate-links)

(when (memq 'tag lk) '(org-activate-tags (1 'org-tag prepend)))

(when (memq 'date lk) '(org-activate-dates (0 'org-date t)))

(when (memq 'footnote lk) '(org-activate-footnote-links))

;; Targets.

;; Diary sexps.

'("^&?%%(.*\\|<%%([^>\n]*?>" (0 'org-sexp-date t))

;; Macro

'(org-fontify-macros)

;; TODO keyword

(list (format org-heading-keyword-regexp-format

org-todo-regexp)

(setq-local org-font-lock-keywords org-font-lock-extra-keywords)

(setq-local font-lock-defaults

'(org-font-lock-keywords t nil nil backward-paragraph))

(kill-local-variable 'font-lock-keywords)

nil))

(list 'invisible t))))

t)))

(defvar-local org-cycle-global-status nil)

(put 'org-cycle-global-status 'org-state t)

(defvar-local org-cycle-subtree-status nil)

(put 'org-cycle-subtree-status 'org-state t)

;;;###autoload

(defun org-cycle (&optional arg)

(org-unlogged-message "Startup visibility, plus VISIBILITY properties"))

((equal arg '(64))

(org-unlogged-message "Entire buffer visible, including drawers"))

((equal arg '(4)) (org-cycle-internal-global))

((run-hook-with-args-until-success

'org-tab-after-check-for-cycling-hook))

((run-hook-with-args-until-success

'org-tab-before-tab-emulation-hook))

(eq org-cycle-global-status 'contents))

;; We just showed the table of contents - now show everything

(run-hook-with-args 'org-pre-cycle-hook 'all)

(unless ga (org-unlogged-message "SHOW ALL"))

(setq org-cycle-global-status 'all)

(run-hook-with-args 'org-cycle-hook 'all))

(defvar org-called-with-limited-levels nil

"Non-nil when `org-with-limited-levels' is currently active.")

(defun org-cycle-internal-local ()

"Do the local cycling action."

(let ((goal-column 0) eoh eol eos has-children children-skipped struct)

(org-show-entry)

(org-with-limited-levels (org-show-children))

(org-show-set-visibility 'canonical)

;; Fold every list in subtree to top-level items.

(when (eq org-cycle-include-plain-lists 'integrate)

(save-excursion

;; now show everything.

(unless (org-before-first-heading-p)

(run-hook-with-args 'org-pre-cycle-hook 'subtree))

(org-unlogged-message

(if children-skipped "SUBTREE (NO CHILDREN)" "SUBTREE"))

(setq org-cycle-subtree-status 'subtree)

(t

;; Default action: hide the subtree.

(run-hook-with-args 'org-pre-cycle-hook 'folded)

(org-unlogged-message "FOLDED")

(setq org-cycle-subtree-status 'folded)

(unless (org-before-first-heading-p)

(if (derived-mode-p 'org-mode) org-cycle-include-plain-lists nil)))

(cond

((integerp arg)

(outline-hide-sublevels arg)

(setq org-cycle-global-status 'contents))

((equal arg '(4))

(org-content))

((or (eq org-startup-folded 'showeverything)

(eq org-startup-folded nil))

(unless (eq org-startup-folded 'showeverything)

(when org-hide-block-startup (org-hide-block-all))

(org-cycle-hide-archived-subtrees 'all)

(org-cycle-hide-drawers 'all)

(org-cycle-show-empty-lines t)))

(interactive)

(defun org-overview ()

"Switch to overview mode, showing only top-level headlines.

This shows all headlines with a level equal or greater than the level

(let ((level

(save-excursion

(goto-char (point-min))

(goto-char (match-beginning 0))

(funcall outline-level)))))

(and level (outline-hide-sublevels level)))))

((eq state 'children) (or (org-subtree-end-visible-p) (recenter 1)))

((eq state 'subtree) (or (org-subtree-end-visible-p) (recenter 1))))))

(defun org-clean-visibility-after-subtree-move ()

"Fix visibility issues after moving a subtree."

;; First, find a reasonable region to look at:

(goto-char (point-min))

(while (re-search-forward re nil t)

(when (and (not (org-invisible-p))

(outline-hide-entry))))

(defun org-cycle-show-empty-lines (state)

"Show empty lines above all visible headlines.

(goto-char (match-beginning 0))

(skip-chars-backward " \t\n")

(line-end-position)))))

;; Never hide empty lines at the end of the file.

(save-excursion

(goto-char (point-max))

(outline-end-of-heading)

(when (and (looking-at "[ \t\n]+")

(= (match-end 0) (point-max)))

(save-excursion

(interactive "P")

;;; Indirect buffer display of subtrees

(defvar org-indirect-dedicated-frame nil

(pop-to-buffer ibuf))

(t (error "Invalid value")))

(narrow-to-region beg end)

(goto-char pos)

(run-hook-with-args 'org-cycle-hook 'all)

(and (window-live-p cwin) (select-window cwin))))

(member arg '((4) (16)))

(and (not invisible-ok)

(invisible-p (max (1- (point)) (point-min)))))

(unless (and blank? (org-previous-line-empty-p))

(org-N-empty-lines-before-current (if blank? 1 0)))

;; At a headline...

((org-at-heading-p)

(cond ((bolp)

;; Preserve tags.

(let ((split (delete-and-extract-region (point) (match-end 4))))

(if (looking-at "[ \t]*$") (replace-match "")

(end-of-line)

(when blank? (insert "\n"))

(insert "\n" stars " ")

(t

(end-of-line)

(when blank? (insert "\n"))

;; On regular text, turn line into a headline or split, if

;; appropriate.

((bolp)

When NO-TAGS is non-nil, don't include tags.

When NO-TODO is non-nil, don't include TODO keywords.

When NO-PRIORITY is non-nil, don't include priority cookie.

(defun org-heading-components ()

"Return the components of the current heading.

- the tags string, or nil."

(save-excursion

(org-back-to-heading t)

(defun org-get-entry ()

"Get the entry text, after heading, entire subtree."

(if old (replace-match new t t nil 4)

(goto-char (or (match-end 3) (match-end 2) (match-end 1)))

(insert " " new))

(when (looking-at "[ \t]*$") (replace-match ""))))))))

(defun org-insert-heading-after-current ()

(user-error "Cannot promote to level 0. UNDO to recover if necessary"))

(t (replace-match up-head nil t)))

(unless (= level 1)

(when org-adapt-indentation (org-fixup-indentation (- diff))))

(run-hooks 'org-after-promote-entry-hook))))

(down-head (concat (make-string (org-get-valid-level level 1) ?*) " "))

(diff (abs (- level (length down-head) -1))))

(replace-match down-head nil t)

(when org-adapt-indentation (org-fixup-indentation diff))

(run-hooks 'org-after-demote-entry-hook))))

((looking-at-p org-outline-regexp) (forward-line))

((looking-at-p "[ \t]*$") (forward-line))

(t

(beginning-of-line)

(or (and (looking-at-p "[ \t]*#\\+BEGIN_\\(EXAMPLE\\|SRC\\)")

(let ((e (org-element-at-point)))

"Move the current subtree down past ARG headlines of the same level."

(interactive "p")

(setq arg (prefix-numeric-value arg))

(defvar org-subtree-clip ""

"Clipboard for cut and paste of subtrees.

of some markers in the region, even if CUT is non-nil. This is

useful if the caller implements cut-and-paste as copy-then-paste-then-cut."

(interactive "p")

(defun org-paste-subtree (&optional level tree for-yank remove)

"Paste the clipboard as a subtree, with modification of headline level.

The entire subtree is promoted or demoted in order to match a new headline

level.

(interactive "P")

(setq tree (or tree (and kill-ring (current-kill 0))))

(unless (org-kill-is-subtree-p tree)

(org-with-limited-levels

(let* ((visp (not (org-invisible-p)))

(txt tree)

(old-level (if (string-match org-outline-regexp-bol txt)

(- (match-end 0) (match-beginning 0) 1)

-1))

(new-level (or force-level (max previous-level next-level)))

(shift (if (or (= old-level -1)

(= new-level -1)

0

(- new-level old-level)))

(delta (if (> shift 0) -1 1))

(org-odd-levels-only nil)

beg end newend)

(setq beg (point))

(insert-before-markers txt)

(unless (string-suffix-p "\n" txt) (insert "\n"))

(setq newend (point))

(setq beg (point))

(when (and (org-invisible-p) visp)

(save-excursion (outline-show-heading)))

(unless (= shift 0)

(save-restriction

(narrow-to-region beg end)

(setq shift (+ delta shift)))

(goto-char (point-min))

(setq newend (point-max))))

(message "Clipboard pasted as level %d subtree" new-level))

(when (and (not for-yank) ; in this case, org-yank will decide about folding

kill-ring

org-subtree-clip-folded)

;; The tree was folded before it was killed/copied

(defun org-kill-is-subtree-p (&optional txt)

"Check if the current kill is an outline subtree, or a set of trees.

(when (and (org-at-heading-p) (not (eobp))) (backward-char 1))

(point)))))))

(defun org-narrow-to-block ()

"Narrow buffer to the current block."

(interactive)

""))) ;No time shift

(doshift

(and (org-string-nw-p shift)

shift)

(user-error "Invalid shift specification %s" shift)))))

(goto-char end-of-tree)

(setq end (point-max))

(setq what "top-level")

(goto-char start)

(setq beg (point))

(when (>= beg end) (goto-char start) (user-error "Nothing to sort"))

(when (and (eq (org-clock-is-active) (current-buffer))

(<= start (marker-position org-clock-marker))

(>= end (marker-position org-clock-marker)))

t))

(dcst (downcase sorting-type))

(case-fold-search nil)

(now (current-time)))

(when restore-clock?

(move-marker org-clock-marker

(1+ (next-single-property-change

(run-hooks 'org-after-sorting-entries-or-items-hook)

(message "Sorting entries...done")))

(defun org-contextualize-keys (alist contexts)

"Return valid elements in ALIST depending on CONTEXTS.

(push r res))))

(delete-dups (delq nil res))))

;;;###autoload

(defun org-run-like-in-org-mode (cmd)

Org mode to the values they have in Org mode, and then interactively

call CMD."

(org-load-modules-maybe)

(let (binds)

(when (or (not (boundp (car var)))

(eq (symbol-value (car var))

(default-value (car var))))

(inherit? (org-property-inherit-p dprop))

(property-re (org-re-property (concat (regexp-quote dprop) "\\+?") t))

(global (and inherit? (org--property-global-value dprop nil))))

(defun org-refresh-property (tprop p &optional inherit)

"Refresh the buffer text property TPROP from the drawer property P.

"???"))

((symbolp org-category) (symbol-name org-category))

(t org-category))))

(defun org-refresh-stats-properties ()

"Refresh stats text properties in the buffer."

(defun org-refresh-effort-properties ()

"Refresh effort properties."

'((effort . identity)

(effort-minutes . org-duration-to-minutes))))

(defun org-find-file-at-mouse (ev)

"Open file link or URL at mouse."

(interactive "e")

"The window configuration before following a link.

This is saved in case the need arises to restore it.")

;;;###autoload

;;;###autoload

(defvar org-open-at-point-functions nil

"Hook that is run when following a link at point.

a link at point. If they don't find anything interesting at point,

they must return nil.")

"Open link, timestamp, footnote or tags at point.

When point is on a link, follow it. Normally, files will be

entry, so it is possible to pick one, or all, of them. If point

is on a tag, call `org-tags-view' instead.

(interactive "P")

(defun org-offer-links-in-entry (buffer marker &optional nth zero)

"Offer links in the current entry and return the selected link.

If there is only one link, return it.

(goto-char marker)

(let ((cnt ?0)

have-zero end links link c)

(push (match-string 0 zero) links)

(setq cnt (1- cnt) have-zero t))

(save-excursion

(org-back-to-heading t)

(setq end (save-excursion (outline-next-heading) (point)))

(push (match-string 0) links))

(setq links (org-uniquify (reverse links))))

(cond

(with-output-to-temp-buffer "*Select Link*"

(dolist (l links)

(cond

(princ (format "[%c] %s\n" (cl-incf cnt)

(org-unbracket-string "<" ">" l))))

(princ (format "[%c] %s (%s)\n" (cl-incf cnt)

(t (princ (format "[%c] %s\n" (cl-incf cnt)

(match-string 1 l)))))))

(org-fit-window-to-buffer (get-buffer-window "*Select Link*"))

(setq link (nth (1- nth) links)))))

(cons link end)))))

;;; File search

(defun org-do-occur (regexp &optional cleanup)

"Call the Emacs command `occur'.

If CLEANUP is non-nil, remove the printout of the regular expression

(goto-char (point-min))

(select-window cwin))))

(defvar org-mark-ring nil

"Mark ring for positions before jumps in Org mode.")

(defvar org-mark-ring-last-goto nil

"Last position in the mark ring used to go back.")

;; Fill and close the ring

(setcdr (nthcdr (1- org-mark-ring-length) org-mark-ring)

org-mark-ring)

(defun org-mark-ring-push (&optional pos buffer)

(interactive)

(defun org-mark-ring-goto (&optional n)

"Jump to the previous position in the mark ring.

(goto-char m)

(when (or (org-invisible-p) (org-invisible-p2)) (org-show-context 'mark-goto))))

;;; Following specific links

(defvar org-agenda-buffer-tmp-name)

(declare-function mailcap-mime-info

"mailcap" (string &optional request no-decode))

(defvar org-wait nil)

;;;; Refiling

(buffer-base-buffer))))

(_ nil))

(mapcar (lambda (s) (replace-regexp-in-string

(org-get-outline-path t t)))

"/"))))

(push (list target f re (org-refile-marker (point)))

"Like `org-refile', but copy."

(interactive)

(let ((org-refile-keep t))

(defun org-refile (&optional arg default-buffer rfloc msg)

"Move the entry or entries at point to another heading.

(setq last-command nil)

(when regionp

(goto-char region-start)

(setq region-start (point))

(unless (or (org-kill-is-subtree-p

(buffer-substring region-start region-end))

(org-back-to-heading t)

(setq heading-text

(replace-regexp-in-string

(or (nth 4 (org-heading-components))

""))))

(org-refile-get-location

(or (outline-next-heading) (goto-char (point-max)))))

(unless (bolp) (newline))

(org-paste-subtree level nil nil t)

(and org-auto-align-tags

(let ((org-loop-over-headlines-in-active-region nil))

(let ((bookmark-name (plist-get org-bookmark-names-plist

:last-refile)))

(when bookmark-name

(unless org-refile-keep

(if regionp

(delete-region (point) (+ (point) (- region-end region-start)))

(when (featurep 'org-inlinetask)

(org-inlinetask-remove-END-maybe))

(setq org-markers-to-move nil)

(unless (re-search-forward org-dblock-end-re nil t)

(error "Dynamic block not terminated"))))))

(defun org-dblock-update (&optional arg)

"User command for updating dynamic blocks.

Update the dynamic block at point. With prefix ARG, update all dynamic

"TITLE:" "TODO:" "TYP_TODO:" "SELECT_TAGS:" "EXCLUDE_TAGS:"))

(defcustom org-structure-template-alist

:group 'org-edit-structure

:type '(repeat

;;;; TODO, DEADLINE, Comments

If the last change removed the TODO tag or switched to DONE, then

this is nil.")

(defvar org-todo-setup-filter-hook nil

"Hook for functions that pre-filter todo specs.

Each function takes a todo spec and returns either nil or the spec

example: when the item starts with TODO, it is changed to DONE.

When it starts with DONE, the DONE is removed. And when neither TODO nor

DONE are present, add TODO at the beginning of the heading.

With a `\\[universal-argument] \\[universal-argument]' prefix, switch to the \

next set of TODO \

keywords (nextset).

With a `\\[universal-argument] \\[universal-argument] \\[universal-argument]' \

prefix, circumvent any state blocking.

With a numeric prefix arg of 0, inhibit note taking for the change.

With a numeric prefix arg of -1, cancel repeater to allow marking as DONE.

(looking-at "\\(?: *\\|[ \t]*$\\)"))

(let* ((match-data (match-data))

(startpos (copy-marker (line-beginning-position)))

(logging (save-match-data (org-entry-get nil "LOGGING" t t)))

(org-log-done org-log-done)

(org-log-repeat org-log-repeat)

(member (member this org-todo-keywords-1))

(tail (cdr member))

(org-state (cond

((eq arg 'right)

(if this

(if tail (car tail) nil)

(car org-todo-keywords-1)))

((eq arg 'left)

(unless (equal member org-todo-keywords-1)

(if this

(nth (- (length org-todo-keywords-1)

(length tail) 2)

org-todo-keywords-1)

(org-last org-todo-keywords-1))))

(arg

;; User or caller requests a specific state.

(cond

(user-error "State `%s' not valid in this file" arg))

((nth (1- (prefix-numeric-value arg))

org-todo-keywords-1))))

((null member) (or head (car org-todo-keywords-1)))

((equal this final-done-word) nil) ;-> make empty

((null tail) nil) ;-> first entry

(run-hook-with-args-until-success

'org-todo-get-default-hook org-state org-last-state)

org-state))

(change-plist (list :type 'todo-state-change :from this :to org-state

:position startpos))

dolog now-done-p)

(setq now-done-p (and (member org-state org-done-keywords)

(not (member this org-done-keywords))))

(and logging (org-local-logging logging))

;; We need to look at recording a time and note.

(nth 2 (assoc this org-todo-log-states))))

(when (and (eq dolog 'note) (eq org-inhibit-logging 'note))

(setq dolog 'time))

(org-add-log-setup 'state org-state this dolog)))

;; Fixup tag positioning.

(org-todo-trigger-tag-changes org-state)

(when org-provide-todo-statistics

(org-update-parent-todo-statistics))

(run-hooks 'org-after-todo-state-change-hook)

(when (and arg (not (member org-state org-done-keywords)))

(setq head (org-get-todo-sequence-head org-state)))

(looking-at org-todo-line-regexp))

(< (point) (+ 2 (or (match-end 2) (match-end 1)))))

(goto-char (or (match-end 2) (match-end 1)))

(when org-trigger-hook

(save-excursion

(run-hook-with-args 'org-trigger-hook change-plist)))

(car org-todo-keywords-1))

(t (nth 2 (assoc kwd org-todo-kwd-alist))))))

"Fast TODO keyword selection with single keys.

(let* ((fulltable org-todo-key-alist)

(done-keywords org-done-keywords) ;; needed for the faces.

(maxlen (apply 'max (mapcar

(lambda (x)

(if (stringp (car x)) (string-width (car x)) 0))

fulltable)))

(fwidth (+ maxlen 3 1 3))

(ncol (/ (- (window-width) 4) fwidth))

(save-excursion

(save-window-excursion

(if expert

(set-buffer (get-buffer-create " *Org todo*"))

(erase-buffer)

(setq-local org-done-keywords done-keywords)

(setq tbl fulltable cnt 0)

(unless (= cnt 0)

(setq cnt 0)

(insert "\n"))

(insert "{ "))

((equal e '(:endgroup))

(insert "}\n"))

((equal e '(:newline))

(unless (= cnt 0)

(setq tbl (cdr tbl)))))

(t

(setq tg (car e) c (cdr e))

(when ingroup (push tg (car groups)))

(setq tg (org-add-props tg nil 'face

(org-get-todo-face tg)))

(when (and (= cnt 0) (not ingroup)) (insert " "))

(insert "[" c "] " tg (make-string

(- fwidth 4 (length tg)) ?\ ))

(insert "\n")

(when ingroup (insert " "))

(setq cnt 0)))))

(insert "\n")

(goto-char (point-min))

(unless expert (org-fit-window-to-buffer))

(setq c (let ((inhibit-quit t)) (read-char-exclusive)))

(cond

((or (= c ?\C-g)

(and (= c ?q) (not (rassoc c fulltable))))

(setq quit-flag t))

((= c ?\ ) nil)

tg)

(t (setq quit-flag t)))))))

(org-log-done nil)

(org-todo-log-states nil)

(end (copy-marker (org-entry-end-position))))

enough to shift date past today. Continue? "

(org-in-regexp org-ts-regexp3)

(setq ts (match-string 1))

(defun org-show-todo-tree (arg)

"Make a compact tree which shows all headlines marked with TODO.

(interactive "P")

(let ((case-fold-search nil)

(kwd-re

((equal arg '(4))

(let ((kwd

(completing-read "Keyword (or KWD1|KWD2|...): "

(match-string 1 old-date)))))

(pcase arg

(`(4)

(`(16)

(save-excursion

(org-back-to-heading t)

(org-read-date-analyze

time default-time (decode-time default-time)))

;; If necessary, get the time from the user

default-time default-input)))))

(org-with-wide-buffer

(org-back-to-heading t)

(forward-line)

(unless (bolp) (insert "\n"))

(let ((beg (point)))

(insert ":" drawer ":\n:END:\n")

(end-of-line -1)))))

(t

(org-end-of-meta-data org-log-state-notes-insert-after-drawers)

(regexp-quote (cdr (assq 'state org-log-note-headings)))

`(("%d" . ,org-ts-regexp-inactive)

("%D" . ,org-ts-regexp)

("%t" . ,org-ts-regexp-inactive)

("%T" . ,org-ts-regexp)

("%u" . ".*?")

(let ((org-inhibit-startup t)) (org-mode))

(insert (format "# Insert note for %s.

# Finish with C-c C-c, or cancel with C-c C-k.\n\n"

(when org-log-note-extra (insert org-log-note-extra))

(setq-local org-finish-function 'org-store-log-note)

(run-hooks 'org-log-buffer-setup-hook)))

(indent-line-to ind)

(insert line)))

(message "Note stored")

;; Fix `buffer-undo-list' when `org-store-log-note' is called

;; from within `org-add-log-note' because `buffer-undo-list'

;; is then modified outside of `org-with-remote-undo'.

(goto-char p1)

(user-error "No more matches"))))