Function: org-babel-execute-src-block

org-babel-execute-src-block is an autoloaded, interactive and byte-compiled function defined in ob-core.el.gz.

Signature

(org-babel-execute-src-block &optional ARG INFO PARAMS EXECUTOR-TYPE)

Documentation

Execute the current source code block and return the result.

Insert the results of execution into the buffer. Source code execution and the collection and formatting of results can be controlled through a variety of header arguments.

With prefix argument ARG, force re-execution even if an existing result cached in the buffer would otherwise have been returned.

Optionally supply a value for INFO in the form returned by org-babel-get-src-block-info.

Optionally supply a value for PARAMS which will be merged with the header arguments specified at the front of the source code block.

EXECUTOR-TYPE is the type of the org element responsible for the execution of the source block. If not provided then informed guess will be made.

Key Bindings

Source Code

;; Defined in /usr/src/emacs/lisp/org/ob-core.el.gz
;;;###autoload
(defun org-babel-execute-src-block (&optional arg info params executor-type)
  "Execute the current source code block and return the result.
Insert the results of execution into the buffer.  Source code
execution and the collection and formatting of results can be
controlled through a variety of header arguments.

With prefix argument ARG, force re-execution even if an existing
result cached in the buffer would otherwise have been returned.

Optionally supply a value for INFO in the form returned by
`org-babel-get-src-block-info'.

Optionally supply a value for PARAMS which will be merged with
the header arguments specified at the front of the source code
block.

EXECUTOR-TYPE is the type of the org element responsible for the
execution of the source block.  If not provided then informed
guess will be made."
  (interactive)
  (let* ((org-babel-current-src-block-location
          (or org-babel-current-src-block-location
              (nth 5 info)
              (org-babel-where-is-src-block-head)))
         (info (if info (copy-tree info) (org-babel-get-src-block-info)))
         (executor-type
          (or executor-type
              ;; If `executor-type' is unset, then we will make an
              ;; informed guess.
              (pcase (and
                      ;; When executing virtual src block, no location
                      ;; is known.
                      org-babel-current-src-block-location
                      (char-after org-babel-current-src-block-location))
                (?s 'inline-src-block)
                (?c 'inline-babel-call)
                (?# (pcase (char-after (+ 2 org-babel-current-src-block-location))
                      (?b 'src-block)
                      (?c 'call-block)
                      (_ 'unknown)))
                (_ 'unknown)))))
    ;; Merge PARAMS with INFO before considering source block
    ;; evaluation since both could disagree.
    (cl-callf org-babel-merge-params (nth 2 info) params)
    (when (org-babel-check-evaluate info)
      (cl-callf org-babel-process-params (nth 2 info))
      (let* ((params (nth 2 info))
	     (cache (let ((c (cdr (assq :cache params))))
		      (and (not arg) c (string= "yes" c))))
	     (new-hash (and cache (org-babel-sha1-hash info :eval)))
	     (old-hash (and cache (org-babel-current-result-hash)))
	     (current-cache (and new-hash (equal new-hash old-hash))))
	(cond
	 (current-cache
	  (save-excursion		;Return cached result.
	    (goto-char (org-babel-where-is-src-block-result nil info))
	    (forward-line)
	    (skip-chars-forward " \t")
	    (let ((result (org-babel-read-result)))
              (unless noninteractive
                (message (format "Cached: %s"
                                 (replace-regexp-in-string "%" "%%" (format "%S" result)))))
	      result)))
	 ((org-babel-confirm-evaluate info)
	  (let* ((lang (nth 0 info))
		 (result-params (cdr (assq :result-params params)))
		 (body (org-babel--expand-body info))
		 (dir (cdr (assq :dir params)))
		 (mkdirp (cdr (assq :mkdirp params)))
		 (default-directory
		  (cond
		   ((not dir) default-directory)
                   ((when-let ((session (org-babel-session-buffer info)))
                      (buffer-local-value 'default-directory (get-buffer session))))
		   ((member mkdirp '("no" "nil" nil))
		    (file-name-as-directory (expand-file-name dir)))
		   (t
		    (let ((d (file-name-as-directory (expand-file-name dir))))
		      (make-directory d 'parents)
		      d))))
		 (cmd (intern (concat "org-babel-execute:" lang)))
		 result exec-start-time)
	    (unless (fboundp cmd)
	      (error "No org-babel-execute function for %s!" lang))
            (unless noninteractive
	      (message "Executing %s %s %s..."
		       (capitalize lang)
                       (pcase executor-type
                         ('src-block "code block")
                         ('inline-src-block "inline code block")
                         ('babel-call "call")
                         ('inline-babel-call "inline call")
                         (e (symbol-name e)))
		       (let ((name (nth 4 info)))
                         (if name
                             (format "(%s)" name)
                           (format "at position %S" (nth 5 info))))))
	    (setq exec-start-time (current-time)
                  result
		  (let ((r
                         ;; Code block may move point in the buffer.
                         ;; Make sure that the point remains on the
                         ;; code block.
                         (save-excursion (funcall cmd body params))))
		    (if (and (eq (cdr (assq :result-type params)) 'value)
			     (or (member "vector" result-params)
				 (member "table" result-params))
			     (not (listp r)))
			(list (list r))
		      r)))
	    (let ((file (and (member "file" result-params)
			     (cdr (assq :file params)))))
	      ;; If non-empty result and :file then write to :file.
	      (when file
		;; If `:results' are special types like `link' or
		;; `graphics', don't write result to `:file'.  Only
		;; insert a link to `:file'.
		(when (and result
			   (not (or (member "link" result-params)
				    (member "graphics" result-params))))
		  (with-temp-file file
		    (insert (org-babel-format-result
			     result
			     (cdr (assq :sep params)))))
		  ;; Set file permissions if header argument
		  ;; `:file-mode' is provided.
		  (when (assq :file-mode params)
		    (set-file-modes file (cdr (assq :file-mode params)))))
		(setq result file))
	      ;; Possibly perform post process provided its
	      ;; appropriate.  Dynamically bind "*this*" to the
	      ;; actual results of the block.
	      (let ((post (cdr (assq :post params))))
		(when post
		  (let ((*this* (if (not file) result
				  (org-babel-result-to-file
				   file
				   (org-babel--file-desc params result)
                                   'attachment))))
		    (setq result (org-babel-ref-resolve post))
		    (when file
		      (setq result-params (remove "file" result-params))))))
	      (unless (member "none" result-params)
                (org-babel-insert-result
                 result result-params info
                 ;; append/prepend cannot handle hash as we accumulate
                 ;; multiple outputs together.
                 (when (member "replace" result-params) new-hash)
                 lang
                 (time-subtract (current-time) exec-start-time))))
	    (run-hooks 'org-babel-after-execute-hook)
	    result)))))))