initial commit

1 files changed, 1311 insertions, 0 deletions

diff --git a/elpa/org-9.5.2/org-src.el b/elpa/org-9.5.2/org-src.el
new file mode 100644
index 0000000..8d02cf4
--- /dev/null
+++ b/elpa/org-9.5.2/org-src.el
@@ -0,0 +1,1311 @@
+;;; org-src.el --- Source code examples in Org       -*- lexical-binding: t; -*-
+;;
+;; Copyright (C) 2004-2021 Free Software Foundation, Inc.
+;;
+;; Author: Carsten Dominik <carsten.dominik@gmail.com>
+;;	   Bastien Guerry <bzg@gnu.org>
+;;         Dan Davison <davison at stats dot ox dot ac dot uk>
+;; Keywords: outlines, hypermedia, calendar, wp
+;; Homepage: https://orgmode.org
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Commentary:
+
+;; This file contains the code dealing with source code examples in
+;; Org mode.
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'ob-comint)
+(require 'org-macs)
+(require 'org-compat)
+(require 'org-keys)
+
+(declare-function org-mode "org" ())
+(declare-function org--get-expected-indentation "org" (element contentsp))
+(declare-function org-element-at-point "org-element" ())
+(declare-function org-element-class "org-element" (datum &optional parent))
+(declare-function org-element-context "org-element" (&optional element))
+(declare-function org-element-lineage "org-element"
+		  (blob &optional types with-self))
+(declare-function org-element-property "org-element" (property element))
+(declare-function org-element-type "org-element" (element))
+(declare-function org-footnote-goto-definition "org-footnote"
+		  (label &optional location))
+
+(defvar org-inhibit-startup)
+
+(defcustom org-edit-src-turn-on-auto-save nil
+  "Non-nil means turn `auto-save-mode' on when editing a source block.
+This will save the content of the source code editing buffer into
+a newly created file, not the base buffer for this source block.
+
+If you want to regularly save the base buffer instead of the source
+code editing buffer, see `org-edit-src-auto-save-idle-delay' instead."
+  :group 'org-edit-structure
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'boolean)
+
+(defcustom org-edit-src-auto-save-idle-delay 0
+  "Delay before saving a source code buffer back into its base buffer.
+When a positive integer N, save after N seconds of idle time.
+When 0 (the default), don't auto-save.
+
+If you want to save the source code buffer itself, don't use this.
+Check `org-edit-src-turn-on-auto-save' instead."
+  :group 'org-edit-structure
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'integer)
+
+(defcustom org-coderef-label-format "(ref:%s)"
+  "The default coderef format.
+This format string will be used to search for coderef labels in literal
+examples (EXAMPLE and SRC blocks).  The format can be overwritten in
+an individual literal example with the -l option, like
+
+#+BEGIN_SRC pascal +n -r -l \"((%s))\"
+...
+#+END_SRC
+
+If you want to use this for HTML export, make sure that the format does
+not introduce special font-locking, and avoid the HTML special
+characters `<', `>', and `&'.  The reason for this restriction is that
+the labels are searched for only after htmlize has done its job."
+  :group 'org-edit-structure ; FIXME this is not in the right group
+  :type 'string)
+
+(defcustom org-edit-fixed-width-region-mode 'artist-mode
+  "The mode that should be used to edit fixed-width regions.
+These are the regions where each line starts with a colon."
+  :group 'org-edit-structure
+  :type '(choice
+	  (const artist-mode)
+	  (const picture-mode)
+	  (const fundamental-mode)
+	  (function :tag "Other (specify)")))
+
+(defcustom org-src-preserve-indentation nil
+  "If non-nil preserve leading whitespace characters on export.
+\\<org-mode-map>
+If non-nil leading whitespace characters in source code blocks
+are preserved on export, and when switching between the org
+buffer and the language mode edit buffer.
+
+When this variable is nil, after editing with `\\[org-edit-src-code]',
+the minimum (across-lines) number of leading whitespace characters
+are removed from all lines, and the code block is uniformly indented
+according to the value of `org-edit-src-content-indentation'."
+  :group 'org-edit-structure
+  :type 'boolean)
+
+(defcustom org-edit-src-content-indentation 2
+  "Indentation for the content of a source code block.
+
+This should be the number of spaces added to the indentation of the #+begin
+line in order to compute the indentation of the block content after
+editing it with `\\[org-edit-src-code]'.
+
+It has no effect if `org-src-preserve-indentation' is non-nil."
+  :group 'org-edit-structure
+  :type 'integer
+  :safe #'wholenump)
+
+(defcustom org-edit-src-persistent-message t
+  "Non-nil means show persistent exit help message while editing src examples.
+The message is shown in the header-line, which will be created in the
+first line of the window showing the editing buffer."
+  :group 'org-edit-structure
+  :type 'boolean)
+
+(defcustom org-src-ask-before-returning-to-edit-buffer t
+  "Non-nil means ask before switching to an existing edit buffer.
+If nil, when `org-edit-src-code' is used on a block that already
+has an active edit buffer, it will switch to that edit buffer
+immediately; otherwise it will ask whether you want to return to
+the existing edit buffer."
+  :group 'org-edit-structure
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'boolean)
+
+(defcustom org-src-window-setup 'reorganize-frame
+  "How the source code edit buffer should be displayed.
+Possible values for this option are:
+
+plain              Show edit buffer using `display-buffer'.  Users can
+                   further control the display behavior by modifying
+                   `display-buffer-alist' and its relatives.
+current-window     Show edit buffer in the current window, keeping all other
+                   windows.
+split-window-below Show edit buffer below the current window, keeping all
+                   other windows.
+split-window-right Show edit buffer to the right of the current window,
+                   keeping all other windows.
+other-window       Use `switch-to-buffer-other-window' to display edit buffer.
+reorganize-frame   Show only two windows on the current frame, the current
+                   window and the edit buffer.
+other-frame        Use `switch-to-buffer-other-frame' to display edit buffer.
+                   Also, when exiting the edit buffer, kill that frame.
+
+Values that modify the window layout (reorganize-frame, split-window-below,
+split-window-right) will restore the layout after exiting the edit buffer."
+  :group 'org-edit-structure
+  :type '(choice
+	  (const current-window)
+	  (const split-window-below)
+	  (const split-window-right)
+	  (const other-frame)
+	  (const other-window)
+	  (const reorganize-frame)))
+
+(defvar org-src-mode-hook nil
+  "Hook run after Org switched a source code snippet to its Emacs mode.
+\\<org-mode-map>
+This hook will run:
+- when editing a source code snippet with `\\[org-edit-special]'
+- when formatting a source code snippet for export with htmlize.
+
+You may want to use this hook for example to turn off `outline-minor-mode'
+or similar things which you want to have when editing a source code file,
+but which mess up the display of a snippet in Org exported files.")
+
+(defcustom org-src-lang-modes
+  '(("C" . c)
+    ("C++" . c++)
+    ("asymptote" . asy)
+    ("bash" . sh)
+    ("beamer" . latex)
+    ("calc" . fundamental)
+    ("cpp" . c++)
+    ("ditaa" . artist)
+    ("dot" . fundamental)
+    ("elisp" . emacs-lisp)
+    ("ocaml" . tuareg)
+    ("screen" . shell-script)
+    ("shell" . sh)
+    ("sqlite" . sql))
+  "Alist mapping languages to their major mode.
+
+The key is the language name.  The value is the mode name, as
+a string or a symbol, without the \"-mode\" suffix.
+
+For many languages this is simple, but for language where this is
+not the case, this variable provides a way to simplify things on
+the user side.  For example, there is no `ocaml-mode' in Emacs,
+but the mode to use is `tuareg-mode'."
+  :group 'org-edit-structure
+  :type '(repeat
+	  (cons
+	   (string "Language name")
+	   (symbol "Major mode"))))
+
+(defcustom org-src-block-faces nil
+  "Alist of faces to be used for source-block.
+Each element is a cell of the format
+
+     (\"language\" FACE)
+
+Where FACE is either a defined face or an anonymous face.
+
+For instance, the following value would color the background of
+emacs-lisp source blocks and python source blocks in purple and
+green, respectability.
+
+    \\='((\"emacs-lisp\" (:background \"#EEE2FF\"))
+      (\"python\" (:background \"#e5ffb8\")))"
+  :group 'org-edit-structure
+  :type '(repeat (list (string :tag "language")
+                       (choice
+                        (face :tag "Face")
+                        (sexp :tag "Anonymous face"))))
+  :version "26.1"
+  :package-version '(Org . "9.0"))
+
+(defcustom org-src-tab-acts-natively t
+  "If non-nil, the effect of TAB in a code block is as if it were
+issued in the language major mode buffer."
+  :type 'boolean
+  :package-version '(Org . "9.4")
+  :group 'org-babel)
+
+
+
+;;; Internal functions and variables
+
+(defvar org-src--auto-save-timer nil
+  "Idle Timer auto-saving remote editing buffers.")
+
+(defvar-local org-src--allow-write-back t)
+(put 'org-src--allow-write-back 'permanent-local t)
+
+(defvar-local org-src--babel-info nil)
+(put 'org-src--babel-info 'permanent-local t)
+
+(defvar-local org-src--beg-marker nil)
+(put 'org-src--beg-marker 'permanent-local t)
+
+(defvar-local org-src--block-indentation nil)
+(put 'org-src--block-indentation 'permanent-local t)
+
+(defvar-local org-src--content-indentation nil)
+(put 'org-src--content-indentation 'permanent-local t)
+
+(defvar-local org-src--end-marker nil)
+(put 'org-src--end-marker 'permanent-local t)
+
+(defvar-local org-src--from-org-mode nil)
+(put 'org-src--from-org-mode 'permanent-local t)
+
+(defvar-local org-src--overlay nil)
+(put 'org-src--overlay 'permanent-local t)
+
+(defvar-local org-src--preserve-indentation nil)
+(put 'org-src--preserve-indentation 'permanent-local t)
+
+(defvar-local org-src--remote nil)
+(put 'org-src--remote 'permanent-local t)
+
+(defvar-local org-src--saved-temp-window-config nil)
+(put 'org-src--saved-temp-window-config 'permanent-local t)
+
+(defvar-local org-src--source-type nil
+  "Type of element being edited, as a symbol.")
+(put 'org-src--source-type 'permanent-local t)
+
+(defvar-local org-src--tab-width nil
+  "Contains `tab-width' value from Org source buffer.
+However, if `indent-tabs-mode' is nil in that buffer, its value
+is 0.")
+(put 'org-src--tab-width 'permanent-local t)
+
+(defvar-local org-src-source-file-name nil
+  "File name associated to Org source buffer, or nil.")
+(put 'org-src-source-file-name 'permanent-local t)
+
+(defvar-local org-src--preserve-blank-line nil)
+(put 'org-src--preserve-blank-line 'permanent-local t)
+
+(defun org-src--construct-edit-buffer-name (org-buffer-name lang)
+  "Construct the buffer name for a source editing buffer."
+  (concat "*Org Src " org-buffer-name "[ " lang " ]*"))
+
+(defun org-src--edit-buffer (beg end)
+  "Return buffer editing area between BEG and END.
+Return nil if there is no such buffer."
+  (catch 'exit
+    (dolist (b (buffer-list))
+      (with-current-buffer b
+	(and (org-src-edit-buffer-p)
+	     (= beg org-src--beg-marker)
+	     (eq (marker-buffer beg) (marker-buffer org-src--beg-marker))
+	     (= end org-src--end-marker)
+	     (eq (marker-buffer end) (marker-buffer org-src--end-marker))
+	     (throw 'exit b))))))
+
+(defun org-src--coordinates (pos beg end)
+  "Return coordinates of POS relatively to BEG and END.
+POS, BEG and END are buffer positions.  Return value is either
+a cons cell (LINE . COLUMN) or symbol `end'.  See also
+`org-src--goto-coordinates'."
+  (if (>= pos end) 'end
+    (org-with-wide-buffer
+     (goto-char (max beg pos))
+     (cons (count-lines (save-excursion (goto-char beg) (line-beginning-position))
+                        (line-beginning-position))
+	   ;; Column is relative to the end of line to avoid problems of
+	   ;; comma escaping or colons appended in front of the line.
+	   (- (point) (min end (line-end-position)))))))
+
+(defun org-src--goto-coordinates (coord beg end)
+  "Move to coordinates COORD relatively to BEG and END.
+COORD are coordinates, as returned by `org-src--coordinates',
+which see.  BEG and END are buffer positions."
+  (goto-char
+   (if (eq coord 'end) (max (1- end) beg)
+     ;; If BEG happens to be located outside of the narrowed part of
+     ;; the buffer, widen it first.
+     (org-with-wide-buffer
+      (goto-char beg)
+      (forward-line (car coord))
+      (max (point)
+           (+ (min end (line-end-position))
+              (cdr coord)))))))
+
+(defun org-src--contents-area (datum)
+  "Return contents boundaries of DATUM.
+DATUM is an element or object.  Return a list (BEG END CONTENTS)
+where BEG and END are buffer positions and CONTENTS is a string."
+  (let ((type (org-element-type datum)))
+    (org-with-wide-buffer
+     (cond
+      ((eq type 'footnote-definition)
+       (let* ((beg (progn
+		     (goto-char (org-element-property :post-affiliated datum))
+		     (search-forward "]")))
+	      (end (or (org-element-property :contents-end datum) beg)))
+	 (list beg end (buffer-substring-no-properties beg end))))
+      ((eq type 'inline-src-block)
+       (let ((beg (progn (goto-char (org-element-property :begin datum))
+			 (search-forward "{" (line-end-position) t)))
+	     (end (progn (goto-char (org-element-property :end datum))
+			 (search-backward "}" (line-beginning-position) t))))
+	 (list beg end (buffer-substring-no-properties beg end))))
+      ((eq type 'latex-fragment)
+       (let ((beg (org-element-property :begin datum))
+	     (end (org-with-point-at (org-element-property :end datum)
+		    (skip-chars-backward " \t")
+		    (point))))
+	 (list beg end (buffer-substring-no-properties beg end))))
+      ((org-element-property :contents-begin datum)
+       (let ((beg (org-element-property :contents-begin datum))
+	     (end (org-element-property :contents-end datum)))
+	 (list beg end (buffer-substring-no-properties beg end))))
+      ((memq type '(example-block export-block src-block))
+       (list (progn (goto-char (org-element-property :post-affiliated datum))
+		    (line-beginning-position 2))
+	     (progn (goto-char (org-element-property :end datum))
+		    (skip-chars-backward " \r\t\n")
+		    (line-beginning-position 1))
+	     (org-element-property :value datum)))
+      ((memq type '(fixed-width latex-environment table))
+       (let ((beg (org-element-property :post-affiliated datum))
+	     (end (progn (goto-char (org-element-property :end datum))
+			 (skip-chars-backward " \r\t\n")
+			 (line-beginning-position 2))))
+	 (list beg
+	       end
+	       (if (eq type 'fixed-width) (org-element-property :value datum)
+		 (buffer-substring-no-properties beg end)))))
+      (t (error "Unsupported element or object: %s" type))))))
+
+(defun org-src--make-source-overlay (beg end edit-buffer)
+  "Create overlay between BEG and END positions and return it.
+EDIT-BUFFER is the buffer currently editing area between BEG and
+END."
+  (let ((overlay (make-overlay beg end)))
+    (overlay-put overlay 'face 'secondary-selection)
+    (overlay-put overlay 'edit-buffer edit-buffer)
+    (overlay-put overlay 'help-echo
+		 "Click with mouse-1 to switch to buffer editing this segment")
+    (overlay-put overlay 'face 'secondary-selection)
+    (overlay-put overlay 'keymap
+		 (let ((map (make-sparse-keymap)))
+		   (define-key map [mouse-1] 'org-edit-src-continue)
+		   map))
+    (let ((read-only
+	   (list
+	    (lambda (&rest _)
+	      (user-error
+	       "Cannot modify an area being edited in a dedicated buffer")))))
+      (overlay-put overlay 'modification-hooks read-only)
+      (overlay-put overlay 'insert-in-front-hooks read-only)
+      (overlay-put overlay 'insert-behind-hooks read-only))
+    overlay))
+
+(defun org-src--remove-overlay ()
+  "Remove overlay from current source buffer."
+  (when (overlayp org-src--overlay) (delete-overlay org-src--overlay)))
+
+(defun org-src--on-datum-p (datum)
+  "Non-nil when point is on DATUM.
+DATUM is an element or an object.  Consider blank lines or white
+spaces after it as being outside."
+  (and (>= (point) (org-element-property :begin datum))
+       (<= (point)
+	   (org-with-wide-buffer
+	    (goto-char (org-element-property :end datum))
+	    (skip-chars-backward " \r\t\n")
+	    (if (eq (org-element-class datum) 'element)
+		(line-end-position)
+	      (point))))))
+
+(defun org-src--contents-for-write-back (write-back-buf)
+  "Populate WRITE-BACK-BUF with contents in the appropriate format.
+Assume point is in the corresponding edit buffer."
+  (let ((indentation-offset
+	 (if org-src--preserve-indentation 0
+	   (+ (or org-src--block-indentation 0)
+	      (if (memq org-src--source-type '(example-block src-block))
+		  org-src--content-indentation
+		0))))
+	(use-tabs? (and (> org-src--tab-width 0) t))
+        (preserve-fl (eq org-src--source-type 'latex-fragment))
+	(source-tab-width org-src--tab-width)
+	(contents (org-with-wide-buffer
+                   (let ((eol (line-end-position)))
+                     (list (buffer-substring (point-min) eol)
+                           (buffer-substring eol (point-max))))))
+	(write-back org-src--allow-write-back)
+        (preserve-blank-line org-src--preserve-blank-line)
+        marker)
+    (with-current-buffer write-back-buf
+      ;; Reproduce indentation parameters from source buffer.
+      (setq indent-tabs-mode use-tabs?)
+      (when (> source-tab-width 0) (setq tab-width source-tab-width))
+      ;; Apply WRITE-BACK function on edit buffer contents.
+      (insert (org-no-properties (car contents)))
+      (setq marker (point-marker))
+      (insert (org-no-properties (car (cdr contents))))
+      (goto-char (point-min))
+      (when (functionp write-back) (save-excursion (funcall write-back)))
+      ;; Add INDENTATION-OFFSET to every line in buffer,
+      ;; unless indentation is meant to be preserved.
+      (when (> indentation-offset 0)
+	(when preserve-fl (forward-line))
+        (while (not (eobp))
+	  (skip-chars-forward " \t")
+          (when (or (not (eolp))                               ; not a blank line
+                    (and (eq (point) (marker-position marker)) ; current line
+                         preserve-blank-line))
+	    (let ((i (current-column)))
+	      (delete-region (line-beginning-position) (point))
+	      (indent-to (+ i indentation-offset))))
+	  (forward-line)))
+      (set-marker marker nil))))
+
+(defun org-src--edit-element
+    (datum name &optional initialize write-back contents remote)
+  "Edit DATUM contents in a dedicated buffer NAME.
+
+INITIALIZE is a function to call upon creating the buffer.
+
+When WRITE-BACK is non-nil, assume contents will replace original
+region.  Moreover, if it is a function, apply it in the edit
+buffer, from point min, before returning the contents.
+
+When CONTENTS is non-nil, display them in the edit buffer.
+Otherwise, show DATUM contents as specified by
+`org-src--contents-area'.
+
+When REMOTE is non-nil, do not try to preserve point or mark when
+moving from the edit area to the source.
+
+Leave point in edit buffer."
+  (when (memq org-src-window-setup '(reorganize-frame
+				     split-window-below
+				     split-window-right))
+    (setq org-src--saved-temp-window-config (current-window-configuration)))
+  (let* ((area (org-src--contents-area datum))
+	 (beg (copy-marker (nth 0 area)))
+	 (end (copy-marker (nth 1 area) t))
+	 (old-edit-buffer (org-src--edit-buffer beg end))
+	 (contents (or contents (nth 2 area))))
+    (if (and old-edit-buffer
+	     (or (not org-src-ask-before-returning-to-edit-buffer)
+		 (y-or-n-p "Return to existing edit buffer ([n] will revert changes)? ")))
+	;; Move to existing buffer.
+	(org-src-switch-to-buffer old-edit-buffer 'return)
+      ;; Discard old edit buffer.
+      (when old-edit-buffer
+	(with-current-buffer old-edit-buffer (org-src--remove-overlay))
+	(kill-buffer old-edit-buffer))
+      (let* ((org-mode-p (derived-mode-p 'org-mode))
+	     (source-file-name (buffer-file-name (buffer-base-buffer)))
+	     (source-tab-width (if indent-tabs-mode tab-width 0))
+	     (type (org-element-type datum))
+	     (block-ind (org-with-point-at (org-element-property :begin datum)
+                          (cond
+                           ((save-excursion (skip-chars-backward " \t") (bolp))
+			    (current-indentation))
+                           ((org-element-property :parent datum)
+                            (org--get-expected-indentation
+                             (org-element-property :parent datum) nil))
+                           (t (current-indentation)))))
+	     (content-ind org-edit-src-content-indentation)
+             (blank-line (save-excursion (beginning-of-line)
+                                         (looking-at-p "^[[:space:]]*$")))
+             (empty-line (and blank-line (looking-at-p "^$")))
+             (preserve-blank-line (or (and blank-line (not empty-line))
+                                      (and empty-line (= (+ block-ind content-ind) 0))))
+	     (preserve-ind
+	      (and (memq type '(example-block src-block))
+		   (or (org-element-property :preserve-indent datum)
+		       org-src-preserve-indentation)))
+	     ;; Store relative positions of mark (if any) and point
+	     ;; within the edited area.
+	     (point-coordinates (and (not remote)
+				     (org-src--coordinates (point) beg end)))
+	     (mark-coordinates (and (not remote)
+				    (org-region-active-p)
+				    (let ((m (mark)))
+				      (and (>= m beg) (>= end m)
+					   (org-src--coordinates m beg end)))))
+	     ;; Generate a new edit buffer.
+	     (buffer (generate-new-buffer name))
+	     ;; Add an overlay on top of source.
+	     (overlay (org-src--make-source-overlay beg end buffer)))
+	;; Switch to edit buffer.
+	(org-src-switch-to-buffer buffer 'edit)
+	;; Insert contents.
+	(insert contents)
+	(remove-text-properties (point-min) (point-max)
+				'(display nil invisible nil intangible nil))
+	(let ((lf (eq type 'latex-fragment)))
+          (unless preserve-ind (org-do-remove-indentation (and lf block-ind) lf)))
+	(set-buffer-modified-p nil)
+	(setq buffer-file-name nil)
+	;; Initialize buffer.
+	(when (functionp initialize)
+	  (let ((org-inhibit-startup t))
+	    (condition-case e
+		(funcall initialize)
+	      (error (message "Initialization fails with: %S"
+			      (error-message-string e))))))
+	;; Transmit buffer-local variables for exit function.  It must
+	;; be done after initializing major mode, as this operation
+	;; may reset them otherwise.
+	(setq org-src--tab-width source-tab-width)
+	(setq org-src--from-org-mode org-mode-p)
+	(setq org-src--beg-marker beg)
+	(setq org-src--end-marker end)
+	(setq org-src--remote remote)
+	(setq org-src--source-type type)
+	(setq org-src--block-indentation block-ind)
+	(setq org-src--content-indentation content-ind)
+	(setq org-src--preserve-indentation preserve-ind)
+	(setq org-src--overlay overlay)
+	(setq org-src--allow-write-back write-back)
+	(setq org-src-source-file-name source-file-name)
+        (setq org-src--preserve-blank-line preserve-blank-line)
+	;; Start minor mode.
+	(org-src-mode)
+	;; Clear undo information so we cannot undo back to the
+	;; initial empty buffer.
+	(buffer-disable-undo (current-buffer))
+	(buffer-enable-undo)
+	;; Move mark and point in edit buffer to the corresponding
+	;; location.
+	(if remote
+	    (progn
+	      ;; Put point at first non read-only character after
+	      ;; leading blank.
+	      (goto-char
+	       (or (text-property-any (point-min) (point-max) 'read-only nil)
+		   (point-max)))
+	      (skip-chars-forward " \r\t\n"))
+	  ;; Set mark and point.
+	  (when mark-coordinates
+	    (org-src--goto-coordinates mark-coordinates (point-min) (point-max))
+	    (push-mark (point) 'no-message t)
+	    (setq deactivate-mark nil))
+	  (org-src--goto-coordinates
+	   point-coordinates (point-min) (point-max)))))))
+
+
+
+;;; Fontification of source blocks
+
+(defun org-src-font-lock-fontify-block (lang start end)
+  "Fontify code block.
+This function is called by Emacs' automatic fontification, as long
+as `org-src-fontify-natively' is non-nil."
+  (let ((lang-mode (org-src-get-lang-mode lang)))
+    (when (fboundp lang-mode)
+      (let ((string (buffer-substring-no-properties start end))
+	    (modified (buffer-modified-p))
+	    (org-buffer (current-buffer)))
+	(remove-text-properties start end '(face nil))
+	(with-current-buffer
+	    (get-buffer-create
+	     (format " *org-src-fontification:%s*" lang-mode))
+	  (let ((inhibit-modification-hooks nil))
+	    (erase-buffer)
+	    ;; Add string and a final space to ensure property change.
+	    (insert string " "))
+	  (unless (eq major-mode lang-mode) (funcall lang-mode))
+	  (org-font-lock-ensure)
+	  (let ((pos (point-min)) next)
+	    (while (setq next (next-property-change pos))
+	      ;; Handle additional properties from font-lock, so as to
+	      ;; preserve, e.g., composition.
+	      (dolist (prop (cons 'face font-lock-extra-managed-props))
+		(let ((new-prop (get-text-property pos prop)))
+		  (put-text-property
+		   (+ start (1- pos)) (1- (+ start next)) prop new-prop
+		   org-buffer)))
+	      (setq pos next))))
+	;; Add Org faces.
+	(let ((src-face (nth 1 (assoc-string lang org-src-block-faces t))))
+          (when (or (facep src-face) (listp src-face))
+            (font-lock-append-text-property start end 'face src-face))
+	  (font-lock-append-text-property start end 'face 'org-block))
+	(add-text-properties
+	 start end
+	 '(font-lock-fontified t fontified t font-lock-multiline t))
+	(set-buffer-modified-p modified)))))
+
+
+;;; Escape contents
+
+(defun org-escape-code-in-region (beg end)
+  "Escape lines between BEG and END.
+Escaping happens when a line starts with \"*\", \"#+\", \",*\" or
+\",#+\" by appending a comma to it."
+  (interactive "r")
+  (save-excursion
+    (goto-char end)
+    (while (re-search-backward "^[ \t]*\\(,*\\(?:\\*\\|#\\+\\)\\)" beg t)
+      (save-excursion (replace-match ",\\1" nil nil nil 1)))))
+
+(defun org-escape-code-in-string (s)
+  "Escape lines in string S.
+Escaping happens when a line starts with \"*\", \"#+\", \",*\" or
+\",#+\" by appending a comma to it."
+  (replace-regexp-in-string "^[ \t]*\\(,*\\(?:\\*\\|#\\+\\)\\)" ",\\1"
+			    s nil nil 1))
+
+(defun org-unescape-code-in-region (beg end)
+  "Un-escape lines between BEG and END.
+Un-escaping happens by removing the first comma on lines starting
+with \",*\", \",#+\", \",,*\" and \",,#+\"."
+  (interactive "r")
+  (save-excursion
+    (goto-char end)
+    (while (re-search-backward "^[ \t]*,*\\(,\\)\\(?:\\*\\|#\\+\\)" beg t)
+      (save-excursion (replace-match "" nil nil nil 1)))))
+
+(defun org-unescape-code-in-string (s)
+  "Un-escape lines in string S.
+Un-escaping happens by removing the first comma on lines starting
+with \",*\", \",#+\", \",,*\" and \",,#+\"."
+  (replace-regexp-in-string
+   "^[ \t]*,*\\(,\\)\\(?:\\*\\|#\\+\\)" "" s nil nil 1))
+
+
+
+;;; Org src minor mode
+
+(defvar org-src-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-c'" 'org-edit-src-exit)
+    (define-key map "\C-c\C-k" 'org-edit-src-abort)
+    (define-key map "\C-x\C-s" 'org-edit-src-save)
+    map))
+
+(define-minor-mode org-src-mode
+  "Minor mode for language major mode buffers generated by Org.
+\\<org-mode-map>
+This minor mode is turned on in two situations:
+  - when editing a source code snippet with `\\[org-edit-special]'
+  - when formatting a source code snippet for export with htmlize.
+
+\\{org-src-mode-map}
+
+See also `org-src-mode-hook'."
+  :lighter " OrgSrc"
+  (when org-edit-src-persistent-message
+    (setq header-line-format
+	  (substitute-command-keys
+	   (if org-src--allow-write-back
+	       "Edit, then exit with `\\[org-edit-src-exit]' or abort with \
+`\\[org-edit-src-abort]'"
+	     "Exit with `\\[org-edit-src-exit]' or abort with \
+`\\[org-edit-src-abort]'"))))
+  ;; Possibly activate various auto-save features (for the edit buffer
+  ;; or the source buffer).
+  (when org-edit-src-turn-on-auto-save
+    (setq buffer-auto-save-file-name
+	  (concat (make-temp-name "org-src-")
+		  (format-time-string "-%Y-%d-%m")
+		  ".txt")))
+  (unless (or org-src--auto-save-timer
+	      (= 0 org-edit-src-auto-save-idle-delay))
+    (setq org-src--auto-save-timer
+	  (run-with-idle-timer
+	   org-edit-src-auto-save-idle-delay t
+	   (lambda ()
+	     (save-excursion
+	       (let (edit-flag)
+		 (dolist (b (buffer-list))
+		   (with-current-buffer b
+		     (when (org-src-edit-buffer-p)
+		       (unless edit-flag (setq edit-flag t))
+		       (when (buffer-modified-p) (org-edit-src-save)))))
+		 (unless edit-flag
+		   (cancel-timer org-src--auto-save-timer)
+		   (setq org-src--auto-save-timer nil)))))))))
+
+(defun org-src-mode-configure-edit-buffer ()
+  "Configure the src edit buffer."
+  (when (bound-and-true-p org-src--from-org-mode)
+    (add-hook 'kill-buffer-hook #'org-src--remove-overlay nil 'local)
+    (if (bound-and-true-p org-src--allow-write-back)
+	(progn
+	  (setq buffer-offer-save t)
+	  (setq write-contents-functions '(org-edit-src-save)))
+      (setq buffer-read-only t))))
+
+(add-hook 'org-src-mode-hook #'org-src-mode-configure-edit-buffer)
+
+
+
+;;; Babel related functions
+
+(defun org-src-associate-babel-session (info)
+  "Associate edit buffer with comint session."
+  (interactive)
+  (let ((session (cdr (assq :session (nth 2 info)))))
+    (and session (not (string= session "none"))
+	 (org-babel-comint-buffer-livep session)
+	 (let ((f (intern (format "org-babel-%s-associate-session"
+                                  (nth 0 info)))))
+           (and (fboundp f) (funcall f session))))))
+
+(defun org-src-babel-configure-edit-buffer ()
+  (when org-src--babel-info
+    (org-src-associate-babel-session org-src--babel-info)))
+
+(add-hook 'org-src-mode-hook #'org-src-babel-configure-edit-buffer)
+
+
+;;; Public API
+
+(defmacro org-src-do-at-code-block (&rest body)
+  "Execute BODY from an edit buffer in the Org mode buffer."
+  (declare (debug (body)))
+  `(let ((beg-marker org-src--beg-marker))
+     (when beg-marker
+       (with-current-buffer (marker-buffer beg-marker)
+	 (goto-char beg-marker)
+	 ,@body))))
+
+(defun org-src-do-key-sequence-at-code-block (&optional key)
+  "Execute key sequence at code block in the source Org buffer.
+The command bound to KEY in the Org-babel key map is executed
+remotely with point temporarily at the start of the code block in
+the Org buffer.
+
+This command is not bound to a key by default, to avoid conflicts
+with language major mode bindings.  To bind it to C-c @ in all
+language major modes, you could use
+
+  (add-hook \\='org-src-mode-hook
+            (lambda () (define-key org-src-mode-map \"\\C-c@\"
+                    \\='org-src-do-key-sequence-at-code-block)))
+
+In that case, for example, C-c @ t issued in code edit buffers
+would tangle the current Org code block, C-c @ e would execute
+the block and C-c @ h would display the other available
+Org-babel commands."
+  (interactive "kOrg-babel key: ")
+  (if (equal key (kbd "C-g")) (keyboard-quit)
+    (org-edit-src-save)
+    (org-src-do-at-code-block
+     (call-interactively (lookup-key org-babel-map key)))))
+
+(defun org-src-get-lang-mode (lang)
+  "Return major mode that should be used for LANG.
+LANG is a string, and the returned major mode is a symbol."
+  (intern
+   (concat
+    (let ((l (or (cdr (assoc lang org-src-lang-modes)) lang)))
+      (if (symbolp l) (symbol-name l) l))
+    "-mode")))
+
+(defun org-src-edit-buffer-p (&optional buffer)
+  "Non-nil when current buffer is a source editing buffer.
+If BUFFER is non-nil, test it instead."
+  (let ((buffer (org-base-buffer (or buffer (current-buffer)))))
+    (and (buffer-live-p buffer)
+	 (local-variable-p 'org-src--beg-marker buffer)
+	 (local-variable-p 'org-src--end-marker buffer))))
+
+(defun org-src-source-buffer ()
+  "Return source buffer edited in current buffer.
+Raise an error when current buffer is not a source editing buffer."
+  (unless (org-src-edit-buffer-p) (error "Not in a source buffer"))
+  (or (marker-buffer org-src--beg-marker)
+      (error "No source buffer available for current editing session")))
+
+(defun org-src-source-type ()
+  "Return type of element edited in current buffer.
+Raise an error when current buffer is not a source editing buffer."
+  (unless (org-src-edit-buffer-p) (error "Not in a source buffer"))
+  org-src--source-type)
+
+(defun org-src-switch-to-buffer (buffer context)
+  (pcase org-src-window-setup
+    (`plain
+     (when (eq context 'exit) (quit-restore-window))
+     (pop-to-buffer buffer))
+    (`current-window (pop-to-buffer-same-window buffer))
+    (`other-window
+     (let ((cur-win (selected-window)))
+       (org-switch-to-buffer-other-window buffer)
+       (when (eq context 'exit) (quit-restore-window cur-win))))
+    (`split-window-below
+     (if (eq context 'exit)
+	 (delete-window)
+       (select-window (split-window-vertically)))
+     (pop-to-buffer-same-window buffer))
+    (`split-window-right
+     (if (eq context 'exit)
+	 (delete-window)
+       (select-window (split-window-horizontally)))
+     (pop-to-buffer-same-window buffer))
+    (`other-frame
+     (pcase context
+       (`exit
+	(let ((frame (selected-frame)))
+	  (switch-to-buffer-other-frame buffer)
+	  (delete-frame frame)))
+       (`save
+	(kill-buffer (current-buffer))
+	(pop-to-buffer-same-window buffer))
+       (_ (switch-to-buffer-other-frame buffer))))
+    (`reorganize-frame
+     (when (eq context 'edit) (delete-other-windows))
+     (org-switch-to-buffer-other-window buffer)
+     (when (eq context 'exit) (delete-other-windows)))
+    (`switch-invisibly (set-buffer buffer))
+    (_
+     (message "Invalid value %s for `org-src-window-setup'"
+	      org-src-window-setup)
+     (pop-to-buffer-same-window buffer))))
+
+(defun org-src-coderef-format (&optional element)
+  "Return format string for block at point.
+
+When optional argument ELEMENT is provided, use that block.
+Otherwise, assume point is either at a source block, at an
+example block.
+
+If point is in an edit buffer, retrieve format string associated
+to the remote source block."
+  (cond
+   ((and element (org-element-property :label-fmt element)))
+   ((org-src-edit-buffer-p) (org-src-do-at-code-block (org-src-coderef-format)))
+   ((org-element-property :label-fmt (org-element-at-point)))
+   (t org-coderef-label-format)))
+
+(defun org-src-coderef-regexp (fmt &optional label)
+  "Return regexp matching a coderef format string FMT.
+
+When optional argument LABEL is non-nil, match coderef for that
+label only.
+
+Match group 1 contains the full coderef string with surrounding
+white spaces.  Match group 2 contains the same string without any
+surrounding space.  Match group 3 contains the label.
+
+A coderef format regexp can only match at the end of a line."
+  (format "\\([ \t]*\\(%s\\)[ \t]*\\)$"
+	  (replace-regexp-in-string
+	   "%s"
+	   (if label (regexp-quote label) "\\([-a-zA-Z0-9_][-a-zA-Z0-9_ ]*\\)")
+	   (regexp-quote fmt)
+	   nil t)))
+
+(defun org-edit-footnote-reference ()
+  "Edit definition of footnote reference at point."
+  (interactive)
+  (let* ((context (org-element-context))
+	 (label (org-element-property :label context)))
+    (unless (and (eq (org-element-type context) 'footnote-reference)
+		 (org-src--on-datum-p context))
+      (user-error "Not on a footnote reference"))
+    (unless label (user-error "Cannot edit remotely anonymous footnotes"))
+    (let* ((definition (org-with-wide-buffer
+			(org-footnote-goto-definition label)
+			(backward-char)
+			(org-element-context)))
+	   (inline? (eq 'footnote-reference (org-element-type definition)))
+	   (contents
+	    (org-with-wide-buffer
+	     (buffer-substring-no-properties
+	      (or (org-element-property :post-affiliated definition)
+		  (org-element-property :begin definition))
+	      (cond
+	       (inline? (1+ (org-element-property :contents-end definition)))
+	       ((org-element-property :contents-end definition))
+	       (t (goto-char (org-element-property :post-affiliated definition))
+		  (line-end-position)))))))
+      (add-text-properties
+       0
+       (progn (string-match (if inline? "\\`\\[fn:.*?:" "\\`.*?\\]") contents)
+	      (match-end 0))
+       '(read-only "Cannot edit footnote label" front-sticky t rear-nonsticky t)
+       contents)
+      (when inline?
+	(let ((l (length contents)))
+	  (add-text-properties
+	   (1- l) l
+	   '(read-only "Cannot edit past footnote reference"
+		       front-sticky nil rear-nonsticky nil)
+	   contents)))
+      (org-src--edit-element
+       definition
+       (format "*Edit footnote [%s]*" label)
+       (let ((source (current-buffer)))
+	 (lambda ()
+	   (org-mode)
+	   (org-clone-local-variables source)))
+       (lambda ()
+	 (if (not inline?) (delete-region (point) (search-forward "]"))
+	   (delete-region (point) (search-forward ":" nil t 2))
+	   (delete-region (1- (point-max)) (point-max))
+	   (when (re-search-forward "\n[ \t]*\n" nil t)
+	     (user-error "Inline definitions cannot contain blank lines"))
+	   ;; If footnote reference belongs to a table, make sure to
+	   ;; remove any newline characters in order to preserve
+	   ;; table's structure.
+	   (when (org-element-lineage definition '(table-cell))
+	     (while (search-forward "\n" nil t) (replace-match " ")))))
+       contents
+       'remote))
+    ;; Report success.
+    t))
+
+(defun org-edit-table.el ()
+  "Edit \"table.el\" table at point.
+\\<org-src-mode-map>
+A new buffer is created and the table is copied into it.  Then
+the table is recognized with `table-recognize'.  When done
+editing, exit with `\\[org-edit-src-exit]'.  The edited text will \
+then replace
+the area in the Org mode buffer.
+
+Throw an error when not at such a table."
+  (interactive)
+  (let ((element (org-element-at-point)))
+    (unless (and (eq (org-element-type element) 'table)
+		 (eq (org-element-property :type element) 'table.el)
+		 (org-src--on-datum-p element))
+      (user-error "Not in a table.el table"))
+    (org-src--edit-element
+     element
+     (org-src--construct-edit-buffer-name (buffer-name) "Table")
+     #'text-mode t)
+    (when (bound-and-true-p flyspell-mode) (flyspell-mode -1))
+    (table-recognize)
+    t))
+
+(defun org-edit-latex-fragment ()
+  "Edit LaTeX fragment at point."
+  (interactive)
+  (let ((context (org-element-context)))
+    (unless (and (eq 'latex-fragment (org-element-type context))
+		 (org-src--on-datum-p context))
+      (user-error "Not on a LaTeX fragment"))
+    (let* ((contents
+	    (buffer-substring-no-properties
+	     (org-element-property :begin context)
+	     (- (org-element-property :end context)
+		(org-element-property :post-blank context))))
+	   (delim-length (if (string-match "\\`\\$[^$]" contents) 1 2)))
+      ;; Make the LaTeX deliminators read-only.
+      (add-text-properties 0 delim-length
+			   (list 'read-only "Cannot edit LaTeX deliminator"
+				 'front-sticky t
+				 'rear-nonsticky t)
+			   contents)
+      (let ((l (length contents)))
+	(add-text-properties (- l delim-length) l
+			     (list 'read-only "Cannot edit LaTeX deliminator"
+				   'front-sticky nil
+				   'rear-nonsticky nil)
+			     contents))
+      (org-src--edit-element
+       context
+       (org-src--construct-edit-buffer-name (buffer-name) "LaTeX fragment")
+       (org-src-get-lang-mode "latex")
+       (lambda ()
+	 ;; Blank lines break things, replace with a single newline.
+	 (while (re-search-forward "\n[ \t]*\n" nil t) (replace-match "\n"))
+	 ;; If within a table a newline would disrupt the structure,
+	 ;; so remove newlines.
+	 (goto-char (point-min))
+	 (when (org-element-lineage context '(table-cell))
+	   (while (search-forward "\n" nil t) (replace-match " "))))
+       contents))
+    t))
+
+(defun org-edit-latex-environment ()
+  "Edit LaTeX environment at point.
+\\<org-src-mode-map>
+The LaTeX environment is copied into a new buffer.  Major mode is
+set to the one associated to \"latex\" in `org-src-lang-modes',
+or to `latex-mode' if there is none.
+
+When done, exit with `\\[org-edit-src-exit]'.  The edited text \
+will then replace
+the LaTeX environment in the Org mode buffer."
+  (interactive)
+  (let ((element (org-element-at-point)))
+    (unless (and (eq (org-element-type element) 'latex-environment)
+		 (org-src--on-datum-p element))
+      (user-error "Not in a LaTeX environment"))
+    (org-src--edit-element
+     element
+     (org-src--construct-edit-buffer-name (buffer-name) "LaTeX environment")
+     (org-src-get-lang-mode "latex")
+     t)
+    t))
+
+(defun org-edit-export-block ()
+  "Edit export block at point.
+\\<org-src-mode-map>
+A new buffer is created and the block is copied into it, and the
+buffer is switched into an appropriate major mode.  See also
+`org-src-lang-modes'.
+
+When done, exit with `\\[org-edit-src-exit]'.  The edited text \
+will then replace
+the area in the Org mode buffer.
+
+Throw an error when not at an export block."
+  (interactive)
+  (let ((element (org-element-at-point)))
+    (unless (and (eq (org-element-type element) 'export-block)
+		 (org-src--on-datum-p element))
+      (user-error "Not in an export block"))
+    (let* ((type (downcase (or (org-element-property :type element)
+			       ;; Missing export-block type.  Fallback
+			       ;; to default mode.
+			       "fundamental")))
+	   (mode (org-src-get-lang-mode type)))
+      (unless (functionp mode) (error "No such language mode: %s" mode))
+      (org-src--edit-element
+       element
+       (org-src--construct-edit-buffer-name (buffer-name) type)
+       mode
+       (lambda () (org-escape-code-in-region (point-min) (point-max)))))
+    t))
+
+(defun org-edit-src-code (&optional code edit-buffer-name)
+  "Edit the source or example block at point.
+\\<org-src-mode-map>
+The code is copied to a separate buffer and the appropriate mode
+is turned on.  When done, exit with `\\[org-edit-src-exit]'.  This \
+will remove the
+original code in the Org buffer, and replace it with the edited
+version.  See `org-src-window-setup' to configure the display of
+windows containing the Org buffer and the code buffer.
+
+When optional argument CODE is a string, edit it in a dedicated
+buffer instead.
+
+When optional argument EDIT-BUFFER-NAME is non-nil, use it as the
+name of the sub-editing buffer."
+  (interactive)
+  (let* ((element (org-element-at-point))
+	 (type (org-element-type element)))
+    (unless (and (memq type '(example-block src-block))
+		 (org-src--on-datum-p element))
+      (user-error "Not in a source or example block"))
+    (let* ((lang
+	    (if (eq type 'src-block) (org-element-property :language element)
+	      "example"))
+	   (lang-f (and (eq type 'src-block) (org-src-get-lang-mode lang)))
+	   (babel-info (and (eq type 'src-block)
+			    (org-babel-get-src-block-info 'light)))
+	   deactivate-mark)
+      (when (and (eq type 'src-block) (not (functionp lang-f)))
+	(error "No such language mode: %s" lang-f))
+      (org-src--edit-element
+       element
+       (or edit-buffer-name
+	   (org-src--construct-edit-buffer-name (buffer-name) lang))
+       lang-f
+       (and (null code)
+	    (lambda () (org-escape-code-in-region (point-min) (point-max))))
+       (and code (org-unescape-code-in-string code)))
+      ;; Finalize buffer.
+      (setq-local org-coderef-label-format
+		  (or (org-element-property :label-fmt element)
+		      org-coderef-label-format))
+      (when (eq type 'src-block)
+	(setq org-src--babel-info babel-info)
+	(let ((edit-prep-func (intern (concat "org-babel-edit-prep:" lang))))
+	  (when (fboundp edit-prep-func)
+	    (funcall edit-prep-func babel-info))))
+      t)))
+
+(defun org-edit-inline-src-code ()
+  "Edit inline source code at point."
+  (interactive)
+  (let ((context (org-element-context)))
+    (unless (and (eq (org-element-type context) 'inline-src-block)
+		 (org-src--on-datum-p context))
+      (user-error "Not on inline source code"))
+    (let* ((lang (org-element-property :language context))
+	   (lang-f (org-src-get-lang-mode lang))
+	   (babel-info (org-babel-get-src-block-info 'light))
+	   deactivate-mark)
+      (unless (functionp lang-f) (error "No such language mode: %s" lang-f))
+      (org-src--edit-element
+       context
+       (org-src--construct-edit-buffer-name (buffer-name) lang)
+       lang-f
+       (lambda ()
+	 ;; Inline source blocks are limited to one line.
+	 (while (re-search-forward "\n[ \t]*" nil t) (replace-match " "))
+	 ;; Trim contents.
+	 (goto-char (point-min))
+	 (skip-chars-forward " \t")
+	 (delete-region (point-min) (point))
+	 (goto-char (point-max))
+	 (skip-chars-backward " \t")
+	 (delete-region (point) (point-max))))
+      ;; Finalize buffer.
+      (setq org-src--babel-info babel-info)
+      (setq org-src--preserve-indentation t)
+      (let ((edit-prep-func (intern (concat "org-babel-edit-prep:" lang))))
+	(when (fboundp edit-prep-func) (funcall edit-prep-func babel-info)))
+      ;; Return success.
+      t)))
+
+(defun org-edit-fixed-width-region ()
+  "Edit the fixed-width ASCII drawing at point.
+\\<org-src-mode-map>
+This must be a region where each line starts with a colon
+followed by a space or a newline character.
+
+A new buffer is created and the fixed-width region is copied into
+it, and the buffer is switched into the major mode defined in
+`org-edit-fixed-width-region-mode', which see.
+
+When done, exit with `\\[org-edit-src-exit]'.  The edited text \
+will then replace
+the area in the Org mode buffer."
+  (interactive)
+  (let ((element (org-element-at-point)))
+    (unless (and (eq (org-element-type element) 'fixed-width)
+		 (org-src--on-datum-p element))
+      (user-error "Not in a fixed-width area"))
+    (org-src--edit-element
+     element
+     (org-src--construct-edit-buffer-name (buffer-name) "Fixed Width")
+     org-edit-fixed-width-region-mode
+     (lambda () (while (not (eobp)) (insert ": ") (forward-line))))
+    ;; Return success.
+    t))
+
+(defun org-edit-src-abort ()
+  "Abort editing of the src code and return to the Org buffer."
+  (interactive)
+  (let (org-src--allow-write-back) (org-edit-src-exit)))
+
+(defun org-edit-src-continue (e)
+  "Unconditionally return to buffer editing area under point.
+Throw an error if there is no such buffer."
+  (interactive "e")
+  (mouse-set-point e)
+  (let ((buf (get-char-property (point) 'edit-buffer)))
+    (if buf (org-src-switch-to-buffer buf 'continue)
+      (user-error "No sub-editing buffer for area at point"))))
+
+(defun org-edit-src-save ()
+  "Save parent buffer with current state source-code buffer."
+  (interactive)
+  (unless (org-src-edit-buffer-p) (user-error "Not in a sub-editing buffer"))
+  (set-buffer-modified-p nil)
+  (let ((write-back-buf (generate-new-buffer "*org-src-write-back*"))
+	(beg org-src--beg-marker)
+	(end org-src--end-marker)
+	(overlay org-src--overlay))
+    (org-src--contents-for-write-back write-back-buf)
+    (with-current-buffer (org-src-source-buffer)
+      (undo-boundary)
+      (goto-char beg)
+      ;; Temporarily disable read-only features of OVERLAY in order to
+      ;; insert new contents.
+      (delete-overlay overlay)
+      (let ((expecting-bol (bolp)))
+	(if (version< emacs-version "27.1")
+	    (progn (delete-region beg end)
+		   (insert (with-current-buffer write-back-buf (buffer-string))))
+	  (save-restriction
+	    (narrow-to-region beg end)
+	    (replace-buffer-contents write-back-buf 0.1 nil)
+	    (goto-char (point-max))))
+	(when (and expecting-bol (not (bolp))) (insert "\n")))
+      (kill-buffer write-back-buf)
+      (save-buffer)
+      (move-overlay overlay beg (point))))
+  ;; `write-contents-functions' requires the function to return
+  ;; a non-nil value so that other functions are not called.
+  t)
+
+(defun org-edit-src-exit ()
+  "Kill current sub-editing buffer and return to source buffer."
+  (interactive)
+  (unless (org-src-edit-buffer-p)
+    (error "Not in a sub-editing buffer"))
+  (let* ((beg org-src--beg-marker)
+	 (end org-src--end-marker)
+	 (write-back org-src--allow-write-back)
+	 (remote org-src--remote)
+	 (coordinates (and (not remote)
+			   (org-src--coordinates (point) 1 (point-max))))
+	 (write-back-buf
+          (and write-back (generate-new-buffer "*org-src-write-back*"))))
+    (when write-back (org-src--contents-for-write-back write-back-buf))
+    (set-buffer-modified-p nil)
+    ;; Switch to source buffer.  Kill sub-editing buffer.
+    (let ((edit-buffer (current-buffer))
+	  (source-buffer (marker-buffer beg)))
+      (unless source-buffer
+        (when write-back-buf (kill-buffer write-back-buf))
+        (error "Source buffer disappeared.  Aborting"))
+      (org-src-switch-to-buffer source-buffer 'exit)
+      (kill-buffer edit-buffer))
+    ;; Insert modified code.  Ensure it ends with a newline character.
+    (org-with-wide-buffer
+     (when (and write-back
+                (not (equal (buffer-substring beg end)
+			    (with-current-buffer write-back-buf
+                              (buffer-string)))))
+       (undo-boundary)
+       (goto-char beg)
+       (let ((expecting-bol (bolp)))
+	 (if (version< emacs-version "27.1")
+	     (progn (delete-region beg end)
+		    (insert (with-current-buffer write-back-buf
+                              (buffer-string))))
+	   (save-restriction
+	     (narrow-to-region beg end)
+	     (replace-buffer-contents write-back-buf 0.1 nil)
+	     (goto-char (point-max))))
+	 (when (and expecting-bol (not (bolp))) (insert "\n")))))
+    (when write-back-buf (kill-buffer write-back-buf))
+    ;; If we are to return to source buffer, put point at an
+    ;; appropriate location.  In particular, if block is hidden, move
+    ;; to the beginning of the block opening line.
+    (unless remote
+      (goto-char beg)
+      (cond
+       ;; Block is hidden; move at start of block.
+       ((cl-some (lambda (o) (eq (overlay-get o 'invisible) 'org-hide-block))
+		 (overlays-at (point)))
+	(beginning-of-line 0))
+       (write-back (org-src--goto-coordinates coordinates beg end))))
+    ;; Clean up left-over markers and restore window configuration.
+    (set-marker beg nil)
+    (set-marker end nil)
+    (when org-src--saved-temp-window-config
+      (unwind-protect
+	  (set-window-configuration org-src--saved-temp-window-config)
+	(setq org-src--saved-temp-window-config nil)))))
+
+(provide 'org-src)
+
+;;; org-src.el ends here