babel: removed ob-interpreters variable -- more natural evaluation decisions

  Babel will now try to evaluate any source code block for which the
  required language-specific functions are defined.

lisp/babel/ob-exp.el

@@ -83,19 +83,18 @@ results - just like none only the block is run on export ensuring
 none ----- do not display either code or results upon export"
   (interactive)
   (message "org-babel-exp processing...")
-  (when (member (nth 0 headers) org-babel-interpreters)
-    (save-excursion
-      (goto-char (match-beginning 0))
-      (let* ((info (org-babel-get-src-block-info))
-	     (params (nth 2 info)))
-	;; expand noweb references in the original file
-	(setf (nth 1 info)
-	      (if (and (cdr (assoc :noweb params))
-		       (string= "yes" (cdr (assoc :noweb params))))
-		  (org-babel-expand-noweb-references
-		   info (get-file-buffer org-current-export-file))
-		(nth 1 info)))
-	(org-babel-exp-do-export info 'block)))))
+  (save-excursion
+    (goto-char (match-beginning 0))
+    (let* ((info (org-babel-get-src-block-info))
+	   (params (nth 2 info)))
+      ;; expand noweb references in the original file
+      (setf (nth 1 info)
+	    (if (and (cdr (assoc :noweb params))
+		     (string= "yes" (cdr (assoc :noweb params))))
+		(org-babel-expand-noweb-references
+		 info (get-file-buffer org-current-export-file))
+	      (nth 1 info)))
+      (org-babel-exp-do-export info 'block))))
 
 (defun org-babel-exp-inline-src-blocks (start end)
   "Process inline src blocks between START and END for export.
@@ -209,11 +208,11 @@ evaluated."
     (case type
       ('inline (format "=%s=" body))
       ('block
-          (let ((str
+	  (let ((str
 		 (format "#+BEGIN_SRC %s %s\n%s%s#+END_SRC\n" lang switches body
 			 (if (and body (string-match "\n$" body))
 			     "" "\n"))))
-            (when name
+	    (when name
 	      (add-text-properties
 	       0 (length str)
 	       (list 'org-caption
@@ -224,12 +223,12 @@ evaluated."
 	    str))
       ('lob
        (let ((call-line (and (string-match "results=" (car args))
-                             (substring (car args) (match-end 0)))))
-         (cond
-          ((eq backend 'html)
-           (format "\n#+HTML: <label class=\"org-src-name\">%s</label>\n"
+			     (substring (car args) (match-end 0)))))
+	 (cond
+	  ((eq backend 'html)
+	   (format "\n#+HTML: <label class=\"org-src-name\">%s</label>\n"
 		   call-line))
-          ((format ": %s\n" call-line))))))))
+	  ((format ": %s\n" call-line))))))))
 
 (defun org-babel-exp-results (info type &optional silent)
   "Return the results of the current code block in a manner
@@ -252,36 +251,38 @@ results into the buffer."
 				  ":" (match-string 2 (cdr pair))))
 	      pair))
 	  (nth 2 info))))
-    (case type
-      ('inline
-        (let ((raw (org-babel-execute-src-block
-                    nil info '((:results . "silent"))))
-              (result-params (split-string (cdr (assoc :results params)))))
-          (unless silent
-	    (cond ;; respect the value of the :results header argument
-	     ((member "file" result-params)
-	      (org-babel-result-to-file raw))
-	     ((or (member "raw" result-params) (member "org" result-params))
-	      (format "%s" raw))
-	     ((member "code" result-params)
-	      (format "src_%s{%s}" lang raw))
-	     (t
-	      (if (stringp raw)
-		  (if (= 0 (length raw)) "=(no results)="
-		    (format "%s" raw))
-		(format "%S" raw)))))))
-      ('block
-          (org-babel-execute-src-block
-	   nil info (org-babel-merge-params
-		     params `((:results . ,(if silent "silent" "replace")))))
-        "")
-      ('lob
-       (save-excursion
-	 (re-search-backward org-babel-lob-one-liner-regexp nil t)
-	 (org-babel-execute-src-block
-	  nil info (org-babel-merge-params
-		    params `((:results . ,(if silent "silent" "replace")))))
-	 "")))))
+    ;; skip code blocks which we can't evaluate
+    (when (fboundp (intern (concat "org-babel-execute:" lang)))
+      (case type
+	('inline
+	  (let ((raw (org-babel-execute-src-block
+		      nil info '((:results . "silent"))))
+		(result-params (split-string (cdr (assoc :results params)))))
+	    (unless silent
+	      (cond ;; respect the value of the :results header argument
+	       ((member "file" result-params)
+		(org-babel-result-to-file raw))
+	       ((or (member "raw" result-params) (member "org" result-params))
+		(format "%s" raw))
+	       ((member "code" result-params)
+		(format "src_%s{%s}" lang raw))
+	       (t
+		(if (stringp raw)
+		    (if (= 0 (length raw)) "=(no results)="
+		      (format "%s" raw))
+		  (format "%S" raw)))))))
+	('block
+	    (org-babel-execute-src-block
+	     nil info (org-babel-merge-params
+		       params `((:results . ,(if silent "silent" "replace")))))
+	  "")
+	('lob
+	 (save-excursion
+	   (re-search-backward org-babel-lob-one-liner-regexp nil t)
+	   (org-babel-execute-src-block
+	    nil info (org-babel-merge-params
+		      params `((:results . ,(if silent "silent" "replace")))))
+	   ""))))))
 
 (provide 'ob-exp)
 ;;; ob-exp.el ends here

lisp/babel/ob.el

@@ -32,9 +32,7 @@
 (eval-when-compile (require 'cl))
 (require 'org)
 
-(defvar org-babel-interpreters nil)
 (defvar org-babel-call-process-region-original)
-(defvar org-babel-lob-one-liner-regexp)
 (declare-function orgtbl-to-generic "org-table" (table params))
 (declare-function org-babel-ref-split-args "ob-ref" (arg-string))
 (declare-function org-babel-ref-variables "ob-ref" (params))
@@ -53,11 +51,27 @@
   "^[ \t]*#\\+\\(srcname\\|source\\|function\\):[ \t]*"
   "Regular expression used to match a source name line.")
 
-(defvar org-babel-src-block-regexp nil
-  "Regexp used to test when inside of a org-babel src-block")
-
-(defvar org-babel-inline-src-block-regexp nil
-  "Regexp used to test when on an inline org-babel src-block")
+(defvar org-babel-src-block-regexp
+  (concat
+   ;; (1) indentation (2)   lang
+   "^\\([ \t]*\\)#\\+begin_src[ \t]+\\([^ \t]+\\)[ \t]*"
+   ;; (3)   switches
+   "\\([^\":\n]*\"[^\"\n*]*\"[^\":\n]*\\|[^\":\n]*\\)"
+   ;; (4)   header arguments
+   "\\([^\n]*\\)\n"
+   ;; (5)   body
+   "\\([^\000]+?\n\\)[ \t]*#\\+end_src")
+  "Regexp used to identify code blocks.")
+
+(defvar org-babel-inline-src-block-regexp
+  (concat
+   ;; (1)   replacement target (2)   lang
+   "[ \f\t\n\r\v]\\(src_\\([^ \t]+\\)"
+   ;; (3,4) (unused, headers)
+   "\\(\\|\\[\\(.*?\\)\\]\\)"
+   ;; (5)   body
+   "{\\([^\f\n\r\v]+?\\)}\\)")
+  "Regexp used to identify inline src-blocks.")
 
 (defun org-babel-get-src-block-info (&optional header-vars-only)
   "Get information of the current source block.
@@ -214,63 +228,6 @@ can not be resolved.")
   (concat org-babel-source-name-regexp (regexp-quote name) "[ \t\n]*"
 	  (substring org-babel-src-block-regexp 1)))
 
-(defun org-babel-add-interpreter (interpreter)
-  "Add INTERPRETER to `org-babel-interpreters' and update
-`org-babel-src-block-regexp' appropriately."
-  (unless (member interpreter org-babel-interpreters)
-    (setq org-babel-interpreters
-          (sort (cons interpreter org-babel-interpreters)
-		(lambda (left right)
-		  (> (length left) (length right)))))
-    (org-babel-set-interpreters 'org-babel-interpreters org-babel-interpreters)))
-
-(defun org-babel-set-interpreters (var value)
-  "Update the regular expressions used to match block and inline
-code."
-  (set-default var value)
-  (setq
-   org-babel-src-block-regexp
-   (concat "^\\([ \t]*\\)#\\+begin_src[ \t]+\\(" ;; (1) indentation (2)   lang
-           (mapconcat 'regexp-quote value "\\|")
-           "\\)[ \t]*"
-           "\\([^\":\n]*\"[^\"\n*]*\"[^\":\n]*\\|[^\":\n]*\\)" ;; (3)   switches
-           "\\([^\n]*\\)\n"                      ;; (4)   header arguments
-           "\\([^\000]+?\n\\)[ \t]*#\\+end_src"));; (5)   body
-  (setq org-babel-inline-src-block-regexp
-	(concat "[ \f\t\n\r\v]\\(src_"                ;; (1)   replacement target
-		"\\("                                 ;; (2)   lang
-		(mapconcat 'regexp-quote value "\\|")
-		"\\)"
-                "\\(\\|\\[\\(.*?\\)\\]\\)"            ;; (3,4) (unused, headers)
-                "{\\([^\f\n\r\v]+?\\)}"               ;; (5)   body
-		"\\)")))
-
-(defcustom org-babel-interpreters '()
-  "Interpreters allows for evaluation tags.
-This is a list of program names (as strings) that can evaluate code and
-insert the output into an Org-mode buffer.  Valid choices are
-
-R          Evaluate R code
-emacs-lisp Evaluate Emacs Lisp code and display the result
-sh         Pass command to the shell and display the result
-perl       The perl interpreter
-python     The python interpreter
-ruby       The ruby interpreter
-
-The source block regexp `org-babel-src-block-regexp' is updated
-when a new interpreter is added to this list through the
-customize interface.  To add interpreters to this variable from
-lisp code use the `org-babel-add-interpreter' function."
-  :group 'org-babel
-  :set 'org-babel-set-interpreters
-  :type '(set :greedy t
-              (const "R")
-	      (const "emacs-lisp")
-              (const "sh")
-	      (const "perl")
-	      (const "python")
-	      (const "ruby")))
-
 ;;; functions
 (defvar call-process-region)
 (defun org-babel-execute-src-block (&optional arg info params)
@@ -318,8 +275,8 @@ block."
     (unwind-protect
         (flet ((call-process-region (&rest args)
                  (apply 'org-babel-tramp-handle-call-process-region args)))
-          (unless (member lang org-babel-interpreters)
-            (error "Language is not in `org-babel-interpreters': %s" lang))
+          (unless (fboundp cmd)
+            (error "No org-babel-execute function for %s!" lang))
           (if (and (not arg) new-hash (equal new-hash old-hash))
               (save-excursion ;; return cached result
                 (goto-char (org-babel-where-is-src-block-result nil info))
@@ -375,13 +332,11 @@ session.  After loading the body this pops open the session."
          (lang (nth 0 info))
          (body (nth 1 info))
          (params (nth 2 info))
-         (session (cdr (assoc :session params))))
-    (unless (member lang org-babel-interpreters)
-      (error "Language is not in `org-babel-interpreters': %s" lang))
-    ;; if called with a prefix argument, then process header arguments
-    (pop-to-buffer
-     (funcall (intern (concat "org-babel-load-session:" lang))
-              session body params))
+         (session (cdr (assoc :session params)))
+	 (cmd (intern (concat "org-babel-load-session:" lang))))
+    (unless (fboundp cmd)
+      (error "No org-babel-load-session function for %s!" lang))
+    (pop-to-buffer (funcall cmd session body params))
     (end-of-line 1)))
 
 (defun org-babel-switch-to-session (&optional arg info)
@@ -397,19 +352,20 @@ of the source block to the kill ring."
          (session (cdr (assoc :session params)))
 	 (dir (cdr (assoc :dir params)))
 	 (default-directory
-	   (or (and dir (file-name-as-directory dir)) default-directory)))
-    (unless (member lang org-babel-interpreters)
-      (error "Language is not in `org-babel-interpreters': %s" lang))
+	   (or (and dir (file-name-as-directory dir)) default-directory))
+	 (cmd (intern (format "org-babel-%s-initiate-session" lang)))
+	 (cmd2 (intern (concat "org-babel-prep-session:" lang))))
+    (unless (fboundp cmd)
+      (error "No org-babel-initiate-session function for %s!" lang))
     ;; copy body to the kill ring
     (with-temp-buffer (insert (org-babel-trim body))
                       (copy-region-as-kill (point-min) (point-max)))
     ;; if called with a prefix argument, then process header arguments
-    (when arg
-      (funcall (intern (concat "org-babel-prep-session:" lang)) session params))
+    (unless (fboundp cmd2)
+      (error "No org-babel-prep-session function for %s!" lang))
+    (when arg (funcall cmd2 session params))
     ;; just to the session using pop-to-buffer
-    (pop-to-buffer
-     (funcall (intern (format "org-babel-%s-initiate-session" lang))
-              session params))
+    (pop-to-buffer (funcall cmd session params))
     (end-of-line 1)))
 
 (defalias 'org-babel-pop-to-session 'org-babel-switch-to-session)