Imported Upstream version 7.9.2

3 files changed, 971 insertions, 0 deletions

diff --git a/contrib/babel/langs/ob-fomus.el b/contrib/babel/langs/ob-fomus.el
new file mode 100644
index 0000000..f7c6ca8
--- /dev/null
+++ b/contrib/babel/langs/ob-fomus.el
@@ -0,0 +1,93 @@
+;;; ob-fomus.el --- org-babel functions for fomus evaluation
+
+;; Copyright (C) 2011-2012 Torsten Anders
+
+;; Author: Torsten Anders
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 
+
+;;; License:
+
+;; This program 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, or (at your option)
+;; any later version.
+;;
+;; This program 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; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating Fomus source code.
+;; For information on Fomus see http://fomus.sourceforge.net/
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in fomus
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'ob)
+(require 'ob-eval)
+
+(defvar org-babel-default-header-args:fomus
+  '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a fomus source block.")
+
+(defun org-babel-expand-body:fomus (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (mapc
+     (lambda (pair)
+       (let ((name (symbol-name (car pair)))
+	     (value (cdr pair)))
+	 (setq body
+	       (replace-regexp-in-string
+		(concat "\$" (regexp-quote name))
+		(if (stringp value) value (format "%S" value))
+		body))))
+     vars)
+    body))
+
+(defun org-babel-execute:fomus (body params)
+  "Execute a block of Fomus code with org-babel.
+This function is called by `org-babel-execute-src-block'."
+  (let* ((result-params (cdr (assoc :result-params params)))
+	 (out-file (cdr (assoc :file params)))
+	 (cmdline (cdr (assoc :cmdline params)))
+	 (cmd (or (cdr (assoc :cmd params)) "fomus"))
+	 (in-file (org-babel-temp-file "fomus-" ".fms")))
+    (with-temp-file in-file
+      (insert (org-babel-expand-body:fomus body params)))
+    ;; TMP: testing
+    ;; (message (concat cmd
+    ;; 	     " " (org-babel-process-file-name in-file)
+    ;; 	     " " cmdline
+    ;; 	     " -o " (org-babel-process-file-name out-file)))
+    (org-babel-eval
+     (concat cmd
+	     " " (org-babel-process-file-name in-file)
+	     " " cmdline
+	     " -o " (org-babel-process-file-name out-file)) "")
+    nil)) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:fomus (session params)
+  "Return an error because Fomus does not support sessions."
+  (error "Fomus does not support sessions"))
+
+(provide 'ob-fomus)
+
+;;; ob-fomus.el ends here
diff --git a/contrib/babel/langs/ob-oz.el b/contrib/babel/langs/ob-oz.el
new file mode 100644
index 0000000..b778b4a
--- /dev/null
+++ b/contrib/babel/langs/ob-oz.el
@@ -0,0 +1,294 @@
+;;; ob-oz.el --- org-babel functions for Oz evaluation
+
+;; Copyright (C) 2009-2012 Torsten Anders and Eric Schulte 
+
+;; Author: Torsten Anders and Eric Schulte 
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.02
+
+;;; License:
+
+;; This program 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, or (at your option)
+;; any later version.
+;;
+;; This program 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; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating Oz source code. 
+;;
+;; Oz code is always send to the Oz Programming Environment (OPI), the
+;; Emacs mode and compiler interface for Oz programs. Therefore, only
+;; session mode is supported. In practice, non-session code blocks are
+;; handled equally well by the session mode. However, only a single
+;; session is supported. Consequently, the :session header argument is
+;; ignored.
+;;
+;; The Org-babel header argument :results is interpreted as
+;; follows. :results output requires the respective code block to be
+;; an Oz statement and :results value requires an Oz
+;; expression. Currently, results are only supported for expressions
+;; (i.e. the result of :results output is always nil).
+;;
+;; Expression evaluation happens synchronously. Therefore there is an
+;; additional header argument :wait-time <number>, which specifies the
+;; maximum time to wait for the result of a given expression. nil
+;; means to wait as long as it takes to get a result (potentially wait
+;; forever).
+;;
+;; NOTE: Currently the copyright of this file may not be in a state to
+;;       permit inclusion as core software into Emacs or Org-mode.
+
+;;; Requirements:
+
+;; - Mozart Programming System, the implementation of the Oz
+;;   programming language (http://www.mozart-oz.org/), which includes
+;;   the major mode mozart for editing Oz programs.
+;;
+;; - StartOzServer.oz which is located in the contrib/scripts
+;;   directory of the Org-mode repository
+
+;;; TODO:
+
+;; - Decide: set communication to \\switch -threadedqueries?
+;;
+;; - Only start Oz compiler when required, e.g., load Org-babel only when needed?
+;;
+;; - Avoid synchronous evaluation to avoid blocking Emacs (complex
+;;   Strasheela programs can take long to find a result..). In order
+;;   to cleanly map code blocks to their associated results (which can
+;;   arrive then in any order) I could use IDs
+;;   (e.g. integers). However, how do I do concurrency in Emacs Lisp,
+;;   and how can I define org-babel-execute:oz concurrently.
+;; 
+;; - Expressions are rarely used in Oz at the top-level, and using
+;;   them in documentation and Literate Programs will cause
+;;   confusion. Idea: hide expression from reader and instead show
+;;   them statement (e.g., MIDI output statement) and then include
+;;   result in Org file. Implementation: for expressions (:results
+;;   value) support an additional header argument that takes arbitrary
+;;   Oz code. This code is not seen by the reader, but will be used
+;;   for the actual expression at the end.  Alternative: feed all
+;;   relevant code as statement (:results output), then add expression
+;;   as extra code block which outputs, e.g., file name (so the file
+;;   name must be accessible by global var), but the code of this
+;;   extra codeblock is not seen.  Hm, in that case it might be even
+;;   more easy to manually add this link to the Org file.
+;;
+
+
+(require 'ob)
+;;; major mode for editing Oz programs
+(require 'mozart)
+
+;;
+;; Interface to communicate with Oz.
+;; (1) For statements without any results: oz-send-string 
+;; (2) For expressions with a single result: oz-send-string-expression
+;;     (defined in org-babel-oz-ResultsValue.el)
+;; 
+
+;; oz-send-string-expression implements an additional very direct
+;; communication between Org-babel and the Oz compiler. Communication
+;; with the Oz server works already without this code via the function
+;; oz-send-string from mozart.el.in, but this function does not get
+;; back any results from Oz to Emacs. The following code creates a
+;; socket for sending code to the OPI compiler and results are
+;; returned by the same socket. On the Oz side, a socket is opened and
+;; conected to the compiler of the OPI (via oz-send-string). On the
+;; Emacs side, a connection to this socket is created for feeding code
+;; and receiving results. This additional communication channel to the
+;; OPI compiler ensures that results are returned cleanly (e.g., only
+;; the result of the sent code is returned, no parsing or any
+;; processing of *Oz Emulator* is required).
+;;
+;; There is no buffer, nor sentinel involved. Oz code is send
+;; directly, and results from Oz are send back, but Emacs Lisp
+;; requires a filter function for processing results.
+
+(defvar org-babel-oz-server-dir
+  (file-name-as-directory
+   (expand-file-name
+    "contrib/scripts"
+    (file-name-as-directory
+     (expand-file-name
+      "../../.."
+      (file-name-directory (or load-file-name buffer-file-name))))))
+  "Path to the contrib/scripts directory in which
+StartOzServer.oz is located.")
+
+(defvar org-babel-oz-port 6001		
+  "Port for communicating with Oz compiler.")
+(defvar org-babel-oz-OPI-socket nil
+  "Socket for communicating with OPI.")
+
+(defvar org-babel-oz-collected-result nil
+  "Aux var to hand result from org-babel-oz-filter to oz-send-string-expression.")
+(defun org-babel-oz-filter (proc string)
+  "Processes output from socket org-babel-oz-OPI-socket."
+;;   (setq org-babel-oz-collected-results (cons string org-babel-oz-collected-results))
+  (setq org-babel-oz-collected-result string)
+  )
+
+
+(defun org-babel-oz-create-socket ()
+  (message "Create OPI socket for evaluating expressions")
+  ;; Start Oz directly 
+  (run-oz)
+  ;; Create socket on Oz side (after Oz was started).
+  (oz-send-string (concat "\\insert '" org-babel-oz-server-dir "StartOzServer.oz'"))
+  ;; Wait until socket is created before connecting to it.
+  ;; Quick hack: wait 3 sec
+  ;; 
+  ;; extending time to 30 secs does not help when starting Emacs for
+  ;; the first time (and computer does nothing else)
+  (sit-for 3)
+  ;; connect to OPI socket
+  (setq org-babel-oz-OPI-socket  
+	;; Creates a socket. I/O interface of Emacs sockets as for processes.
+	(open-network-stream "*Org-babel-OPI-socket*" nil "localhost" org-babel-oz-port))
+  ;; install filter
+  (set-process-filter org-babel-oz-OPI-socket #'org-babel-oz-filter)
+)
+
+;; communication with org-babel-oz-OPI-socket is asynchronous, but
+;; oz-send-string-expression turns is into synchronous...
+(defun oz-send-string-expression (string &optional wait-time)
+  "Similar to oz-send-string, oz-send-string-expression sends a string to the OPI compiler. However, string must be expression and this function returns the result of the expression (as string). oz-send-string-expression is synchronous, wait-time allows to specify a maximum wait time. After wait-time is over with no result, the function returns nil."
+  (if (not org-babel-oz-OPI-socket) 
+      (org-babel-oz-create-socket))
+  (let ((polling-delay 0.1)
+	result)
+    (process-send-string org-babel-oz-OPI-socket string)
+    ;; wait for result
+    (if wait-time
+	(let ((waited 0))
+	  (unwind-protect
+	      (progn
+		(while 
+		    ;; stop loop if org-babel-oz-collected-result \= nil or waiting time is over
+		    (not (or (not (equal org-babel-oz-collected-result nil))
+			     (> waited wait-time)))
+		  (progn 
+		    (sit-for polling-delay)
+;; 		    (message "org-babel-oz: next polling iteration")
+		    (setq waited (+ waited polling-delay))))
+;; 		(message "org-babel-oz: waiting over, got result or waiting timed out")
+;; 		(message (format "wait-time: %s, waited: %s" wait-time waited))
+		(setq result org-babel-oz-collected-result)
+		(setq org-babel-oz-collected-result nil))))
+      (unwind-protect
+	  (progn
+	    (while (equal org-babel-oz-collected-result nil)
+	      (sit-for polling-delay))
+	    (setq result org-babel-oz-collected-result)
+	    (setq org-babel-oz-collected-result nil))))
+    result))
+
+(defun org-babel-expand-body:oz (body params)
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (if vars
+	;; prepend code to define all arguments passed to the code block
+	(let ((var-string (mapcar (lambda (pair)
+				    (format "%s=%s"
+					    (car pair)
+					    (org-babel-oz-var-to-oz (cdr pair))))
+				  vars)))
+	  ;; only add var declarations if any variables are there
+	  (mapconcat #'identity
+		     (append (list "local") var-string (list "in" body "end"))
+		     "\n"))
+      body)))
+
+(defun org-babel-execute:oz (body params)
+  "Execute a block of Oz code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (let* ((result-params (cdr (assoc :result-params params)))
+	 (full-body (org-babel-expand-body:oz body params))
+	 (wait-time (plist-get params :wait-time)))
+    ;; actually execute the source-code block
+    (org-babel-reassemble-table
+     (cond
+      ((member "output" result-params)
+       (message "Org-babel: executing Oz statement")
+       (oz-send-string full-body))
+      ((member "value" result-params)
+       (message "Org-babel: executing Oz expression")
+       (oz-send-string-expression full-body (or wait-time 1)))
+      (t (error "either 'output' or 'results' must be members of :results.")))
+     (org-babel-pick-name (cdr (assoc :colname-names params))
+			  (cdr (assoc :colnames params)))
+     (org-babel-pick-name (cdr (assoc :roname-names params))
+			  (cdr (assoc :rownames params))))))
+
+;; This function should be used to assign any variables in params in
+;; the context of the session environment.
+(defun org-babel-prep-session:oz (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (error "org-babel-prep-session:oz unimplemented"))
+;; TODO: testing... (copied from org-babel-haskell.el)
+;; (defun org-babel-prep-session:oz (session params)
+;;   "Prepare SESSION according to the header arguments specified in PARAMS."
+;;   (save-window-excursion
+;;     (org-babel-oz-initiate-session session)
+;;     (let* ((vars (org-babel-ref-variables params))
+;;            (var-lines (mapconcat ;; define any variables
+;;                        (lambda (pair)
+;;                          (format "%s=%s"
+;;                                  (car pair)
+;;                                  (org-babel-ruby-var-to-ruby (cdr pair))))
+;;                        vars "\n"))
+;;            (vars-file (concat (make-temp-file "org-babel-oz-vars") ".oz")))
+;;       (when vars
+;;         (with-temp-buffer
+;;           (insert var-lines) (write-file vars-file)
+;;           (oz-mode) 
+;; ;; 	  (inferior-oz-load-file) ; ??
+;; 	  ))
+;;       (current-buffer))))
+;;
+
+
+;; TODO: testing... (simplified version of def in org-babel-prep-session:ocaml)
+;;
+;; BUG: does not work yet. Error: ad-Orig-error: buffer none doesn't exist or has no process 
+;; UNUSED DEF
+(defun org-babel-oz-initiate-session (&optional session params)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session."
+  (unless (string= session "none")
+    ;; TODO: make it possible to have multiple sessions
+    (save-window-excursion
+      ;; (run-oz)
+      (get-buffer oz-compiler-buffer))))
+
+(defun org-babel-oz-var-to-oz (var)
+  "Convert an elisp var into a string of Oz source code
+specifying a var of the same value."
+  (if (listp var)
+;;       (concat "[" (mapconcat #'org-babel-oz-var-to-oz var ", ") "]")
+      (eval var) 
+    (format "%s" var) ; don't preserve string quotes. 
+;;     (format "%s" var)
+    ))
+
+;; TODO: 
+(defun org-babel-oz-table-or-string (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (error "org-babel-oz-table-or-string unimplemented"))
+
+
+(provide 'ob-oz)
+;;; org-babel-oz.el ends here
diff --git a/contrib/babel/library-of-babel.org b/contrib/babel/library-of-babel.org
new file mode 100644
index 0000000..0098e72
--- /dev/null
+++ b/contrib/babel/library-of-babel.org
@@ -0,0 +1,584 @@
+#+title:    The Library of Babel
+#+author:     Org-mode People
+#+STARTUP:  hideblocks
+
+* Introduction
+
+The Library of Babel is an extensible collection of ready-made and
+easily-shortcut-callable source-code blocks for handling common tasks.
+Org-babel comes pre-populated with the source-code blocks located in
+this file.  It is possible to add source-code blocks from any org-mode
+file to the library by calling =(org-babel-lob-ingest
+"path/to/file.org")=.
+
+This file is included in worg mainly less for viewing through the web
+interface, and more for contribution through the worg git repository.
+If you have code snippets that you think others may find useful please
+add them to this file and [[file:~/src/worg/worg-git.org::contribute-to-worg][contribute them]] to worg.
+
+The raw Org-mode text of this file can be downloaded at
+[[repofile:contrib/babel/library-of-babel.org][library-of-babel.org]]
+
+* Simple
+
+A collection of simple utility functions:
+
+#+name: echo
+#+begin_src emacs-lisp :var input="echo'd"
+  input
+#+end_src
+
+* File I/O
+
+** Reading and writing files
+
+Read the contents of the file at =file=.  The =:results vector= and
+=:results scalar= header arguments can be used to read the contents of
+file as either a table or a string.
+
+#+name: read
+#+begin_src emacs-lisp :var file="" :var format=""
+  (if (string= format "csv")
+      (with-temp-buffer
+        (org-table-import (expand-file-name file) nil)
+        (org-table-to-lisp))
+    (with-temp-buffer
+      (insert-file-contents (expand-file-name file))
+      (buffer-string)))
+#+end_src
+
+Write =data= to a file at =file=.  If =data= is a list, then write it
+as a table in traditional Org-mode table syntax.
+
+#+name: write
+#+begin_src emacs-lisp :var data="" :var file="" :var ext='()
+  (flet ((echo (r) (if (stringp r) r (format "%S" r))))
+    (with-temp-file file
+      (case (and (listp data)
+                 (or ext (intern (file-name-extension file))))
+        ('tsv (insert (orgtbl-to-tsv data '(:fmt echo))))
+        ('csv (insert (orgtbl-to-csv data '(:fmt echo))))
+        (t    (org-babel-insert-result data)))))
+  nil
+#+end_src
+
+** Remote files
+
+*** json
+
+Read local or remote file in [[http://www.json.org/][json]] format into emacs-lisp objects.
+
+#+name: json
+#+begin_src emacs-lisp :var file='() :var url='()
+  (require 'json)
+  (cond
+   (file
+    (with-temp-filebuffer file
+      (goto-char (point-min))
+      (json-read)))
+   (url
+    (require 'w3m)
+    (with-temp-buffer
+      (w3m-retrieve url)
+      (goto-char (point-min))
+      (json-read))))
+#+end_src
+
+*** Google docs
+
+The following code blocks make use of the [[http://code.google.com/p/googlecl/][googlecl]] Google command line
+tool.  This tool provides functionality for accessing Google services
+from the command line, and the following code blocks use /googlecl/
+for reading from and writing to Google docs with Org-mode code blocks.
+
+**** Read a document from Google docs
+
+The =google= command seems to be throwing "Moved Temporarily" errors
+when trying to download textual documents, but this is working fine
+for spreadsheets.
+
+#+name: gdoc-read
+#+begin_src emacs-lisp :var title="example" :var format="csv"
+  (let* ((file (concat title "." format))
+         (cmd (format "google docs get --format %S --title %S" format title)))
+    (message cmd) (message (shell-command-to-string cmd))
+    (prog1 (if (string= format "csv")
+               (with-temp-buffer
+                 (org-table-import (shell-quote-argument file) '(4))
+                 (org-table-to-lisp))
+             (with-temp-buffer
+               (insert-file-contents (shell-quote-argument file))
+               (buffer-string)))
+      (delete-file file)))
+#+end_src
+
+For example, a line like the following can be used to read the
+contents of a spreadsheet named =num-cells= into a table.
+: #+call: gdoc-read(title="num-cells"")
+
+A line like the following can be used to read the contents of a
+document as a string.
+
+: #+call: gdoc-read(title="loremi", :format "txt")
+
+**** Write a document to a Google docs
+
+Write =data= to a google document named =title=.  If =data= is tabular
+it will be saved to a spreadsheet, otherwise it will be saved as a
+normal document.
+
+#+name: gdoc-write
+#+begin_src emacs-lisp :var title="babel-upload" :var data=fibs(n=10) :results silent
+  (let* ((format (if (listp data) "csv" "txt"))
+         (tmp-file (make-temp-file "org-babel-google-doc" nil (concat "." format)))
+         (cmd (format "google docs upload --title %S %S" title tmp-file)))
+    (with-temp-file tmp-file
+      (insert
+       (if (listp data)
+           (orgtbl-to-csv
+            data '(:fmt (lambda (el) (if (stringp el) el (format "%S" el)))))
+         (if (stringp data) data (format "%S" data)))))
+    (message cmd)
+    (prog1 (shell-command-to-string cmd) (delete-file tmp-file)))
+#+end_src
+
+example usage
+: #+name: fibs
+: #+begin_src emacs-lisp :var n=8
+:   (flet ((fib (m) (if (< m 2) 1 (+ (fib (- m 1)) (fib (- m 2))))))
+:     (mapcar (lambda (el) (list el (fib el))) (number-sequence 0 (- n 1))))
+: #+end_src
+:
+: #+call: gdoc-write(title="fibs", data=fibs(n=10))
+
+* Plotting code
+
+** R
+
+Plot column 2 (y axis) against column 1 (x axis). Columns 3 and
+beyond, if present, are ignored.
+
+#+name: R-plot
+#+begin_src R :var data=R-plot-example-data
+plot(data)
+#+end_src
+
+#+tblname: R-plot-example-data
+| 1 |  2 |
+| 2 |  4 |
+| 3 |  9 |
+| 4 | 16 |
+| 5 | 25 |
+
+#+call: R-plot(data=R-plot-example-data)
+
+#+resname: R-plot(data=R-plot-example-data)
+: nil
+
+** Gnuplot
+
+* Org reference
+
+** Headline references
+
+#+name: headline
+#+begin_src emacs-lisp :var headline=top :var file='()
+  (save-excursion
+    (when file (get-file-buffer file))
+    (org-open-link-from-string (org-make-link-string headline))
+    (save-restriction
+      (org-narrow-to-subtree)
+      (buffer-string)))
+#+end_src
+
+#+call: headline(headline="headline references")
+
+* Tables
+
+** LaTeX Table Export
+
+*** booktabs
+
+This source block can be used to wrap a table in the latex =booktabs=
+environment. The source block adds a =toprule= and =bottomrule= (so
+don't use =hline= at the top or bottom of the table).  The =hline=
+after the header is replaced with a =midrule=.
+
+Note that this function bypasses the Org-mode LaTeX exporter and calls
+=orgtbl-to-generic= to create the output table.  This means that the
+entries in the table are not translated from Org-mode to LaTeX.
+
+It takes the following arguments -- all but the first two are
+optional.
+
+| arg   | description                                |
+|-------+--------------------------------------------|
+| table | a reference to the table                   |
+| align | alignment string                           |
+| env   | optional environment, default to "tabular" |
+| width | optional width specification string        |
+
+#+name: booktabs
+#+begin_src emacs-lisp :var table='((:head) hline (:body)) :var align='() :var env="tabular" :var width='() :noweb yes :results latex
+  (flet ((to-tab (tab)
+                 (orgtbl-to-generic
+                  (mapcar (lambda (lis)
+                            (if (listp lis)
+                                (mapcar (lambda (el)
+                                          (if (stringp el)
+                                              el
+                                            (format "%S" el))) lis)
+                              lis)) tab)
+                  (list :lend " \\\\" :sep " & " :hline "\\hline"))))
+    (org-fill-template
+     "
+  \\begin{%env}%width%align
+  \\toprule
+  %table
+  \\bottomrule
+  \\end{%env}\n"
+     (list
+      (cons "env"       (or env "table"))
+      (cons "width"     (if width (format "{%s}" width) ""))
+      (cons "align"     (if align (format "{%s}" align) ""))
+      (cons "table"
+            ;; only use \midrule if it looks like there are column headers
+            (if (equal 'hline (second table))
+                (concat (to-tab (list (first table)))
+                        "\n\\midrule\n"
+                        (to-tab (cddr table)))
+              (to-tab table))))))
+#+end_src
+
+*** longtable
+
+This block can be used to wrap a table in the latex =longtable=
+environment, it takes the following arguments -- all but the first two
+are optional.
+
+| arg       | description                                                 |
+|-----------+-------------------------------------------------------------|
+| table     | a reference to the table                                    |
+| align     | optional alignment string                                   |
+| width     | optional width specification string                         |
+| hline     | the string to use as hline separator, defaults to "\\hline" |
+| head      | optional "head" string                                      |
+| firsthead | optional "firsthead" string                                 |
+| foot      | optional "foot" string                                      |
+| lastfoot  | optional "lastfoot" string                                  |
+
+#+name: longtable
+#+begin_src emacs-lisp :var table='((:table)) :var align='() :var width='() :var hline="\\hline" :var firsthead='() :var head='() :var foot='() :var lastfoot='() :noweb yes :results latex
+  (org-fill-template
+   "
+  \\begin{longtable}%width%align
+  %firsthead
+  %head
+  %foot
+  %lastfoot
+
+  %table
+  \\end{longtable}\n"
+   (list
+    (cons "width"     (if width (format "{%s}" width) ""))
+    (cons "align"     (if align (format "{%s}" align) ""))
+    (cons "firsthead" (if firsthead (concat firsthead "\n\\endfirsthead\n") ""))
+    (cons "head"      (if head (concat head "\n\\endhead\n") ""))
+    (cons "foot"      (if foot (concat foot "\n\\endfoot\n") ""))
+    (cons "lastfoot"  (if lastfoot (concat lastfoot "\n\\endlastfoot\n") ""))
+    (cons "table" (orgtbl-to-generic
+                   (mapcar (lambda (lis)
+                             (if (listp lis)
+                                 (mapcar (lambda (el)
+                                           (if (stringp el)
+                                               el
+                                             (format "%S" el))) lis)
+                               lis)) table)
+                   (list :lend " \\\\" :sep " & " :hline hline)))))
+#+end_src
+
+*** booktabs-notes
+
+This source block builds on [[booktabs]].  It accepts two additional
+arguments, both of which are optional.
+
+#+tblname: arguments
+| arg    | description                                          |
+|--------+------------------------------------------------------|
+| notes  | an org-mode table with footnotes                     |
+| lspace | if non-nil, insert =addlinespace= after =bottomrule= |
+
+An example footnote to the =arguments= table specifies the column
+span. Note the use of LaTeX, rather than Org-mode, markup.
+
+#+tblname: arguments-notes
+| \multicolumn{2}{l}{This is a footnote to the \emph{arguments} table.} |
+
+#+name: booktabs-notes
+#+begin_src emacs-lisp :var table='((:head) hline (:body)) :var notes='() :var align='() :var env="tabular" :var width='() :var lspace='() :noweb yes :results latex
+  (flet ((to-tab (tab)
+                 (orgtbl-to-generic
+                  (mapcar (lambda (lis)
+                            (if (listp lis)
+                                (mapcar (lambda (el)
+                                          (if (stringp el)
+                                              el
+                                            (format "%S" el))) lis)
+                              lis)) tab)
+                  (list :lend " \\\\" :sep " & " :hline "\\hline"))))
+    (org-fill-template
+     "
+    \\begin{%env}%width%align
+    \\toprule
+    %table
+    \\bottomrule%spacer
+    %notes
+    \\end{%env}\n"
+     (list
+      (cons "env"       (or env "table"))
+      (cons "width"     (if width (format "{%s}" width) ""))
+      (cons "align"     (if align (format "{%s}" align) ""))
+      (cons "spacer"    (if lspace "\\addlinespace" ""))
+      (cons "table"
+            ;; only use \midrule if it looks like there are column headers
+            (if (equal 'hline (second table))
+                (concat (to-tab (list (first table)))
+                        "\n\\midrule\n"
+                        (to-tab (cddr table)))
+              (to-tab table)))
+      (cons "notes" (if notes (to-tab notes) ""))
+      )))
+#+end_src
+
+** Elegant lisp for transposing a matrix
+
+#+tblname: transpose-example
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |
+
+#+name: transpose
+#+begin_src emacs-lisp :var table=transpose-example
+  (apply #'mapcar* #'list table)
+#+end_src
+
+#+resname:
+| 1 | 4 |
+| 2 | 5 |
+| 3 | 6 |
+
+** Convert every element of a table to a string
+
+#+tblname: hetero-table
+| 1 | 2 | 3 |
+| a | b | c |
+
+#+name: all-to-string
+#+begin_src emacs-lisp :var tbl='()
+  (defun all-to-string (tbl)
+    (if (listp tbl)
+        (mapcar #'all-to-string tbl)
+      (if (stringp tbl)
+          tbl
+        (format "%s" tbl))))
+  (all-to-string tbl)
+#+end_src
+
+#+begin_src emacs-lisp :var tbl=hetero-table
+  (mapcar (lambda (row) (mapcar (lambda (cell) (stringp cell)) row)) tbl)
+#+end_src
+
+#+name:
+| nil | nil | nil |
+| t   | t   | t   |
+
+#+begin_src emacs-lisp :var tbl=all-to-string(hetero-table)
+  (mapcar (lambda (row) (mapcar (lambda (cell) (stringp cell)) row)) tbl)
+#+end_src
+
+#+name:
+| t | t | t |
+| t | t | t |
+
+* Misc
+
+** File-specific Version Control logging
+   :PROPERTIES:
+   :AUTHOR: Luke Crook
+   :END:
+
+This function will attempt to retrieve the entire commit log for the
+file associated with the current buffer and insert this log into the
+export. The function uses the Emacs VC commands to interface to the
+local version control system, but has only been tested to work with
+Git. 'limit' is currently unsupported.
+
+#+name: vc-log
+#+headers: :var limit=-1
+#+headers: :var buf=(buffer-name (current-buffer))
+#+begin_src emacs-lisp
+  ;; Most of this code is copied from vc.el vc-print-log
+  (require 'vc)
+  (when (vc-find-backend-function
+         (vc-backend (buffer-file-name (get-buffer buf))) 'print-log)
+    (let ((limit -1)
+          (vc-fileset nil)
+          (backend nil)
+          (files nil))
+      (with-current-buffer (get-buffer buf)
+        (setq vc-fileset (vc-deduce-fileset t)) ; FIXME: Why t? --Stef
+        (setq backend (car vc-fileset))
+        (setq files (cadr vc-fileset)))
+      (with-temp-buffer
+        (let ((status (vc-call-backend
+                       backend 'print-log files (current-buffer))))
+          (when (and (processp status)   ; Make sure status is a process
+                     (= 0 (process-exit-status status))) ; which has not terminated
+            (while (not (eq 'exit (process-status status)))
+              (sit-for 1 t)))
+          (buffer-string)))))
+#+end_src
+
+** Trivial python code blocks
+
+#+name: python-identity
+#+begin_src python :var a=1
+a
+#+end_src
+
+#+name: python-add
+#+begin_src python :var a=1 :var b=2
+a + b
+#+end_src
+
+** Arithmetic
+
+#+name: lob-add
+#+begin_src emacs-lisp :var a=0 :var b=0
+  (+ a b)
+#+end_src
+
+#+name: lob-minus
+#+begin_src emacs-lisp :var a=0 :var b=0
+  (- a b)
+#+end_src
+
+#+name: lob-times
+#+begin_src emacs-lisp :var a=0 :var b=0
+  (* a b)
+#+end_src
+
+#+name: lob-div
+#+begin_src emacs-lisp :var a=0 :var b=0
+  (/ a b)
+#+end_src
+
+* GANTT Charts
+
+The =elispgantt= source block was sent to the mailing list by Eric
+Fraga.  It was modified slightly by Tom Dye.
+
+#+name: elispgantt
+#+begin_src emacs-lisp :var table=gantttest
+  (let ((dates "")
+        (entries (nthcdr 2 table))
+        (milestones "")
+        (nmilestones 0)
+        (ntasks 0)
+        (projecttime 0)
+        (tasks "")
+        (xlength 1))
+    (message "Initial: %s\n" table)
+    (message "Entries: %s\n" entries)
+    (while entries
+      (let ((entry (first entries)))
+        (if (listp entry)
+            (let ((id (first entry))
+                  (type (nth 1 entry))
+                  (label (nth 2 entry))
+                  (task (nth 3 entry))
+                  (dependencies (nth 4 entry))
+                  (start (nth 5 entry))
+                  (duration (nth 6 entry))
+                  (end (nth 7 entry))
+                  (alignment (nth 8 entry)))
+              (if (> start projecttime) (setq projecttime start))
+              (if (string= type "task")
+                  (let ((end (+ start duration))
+                        (textposition (+ start (/ duration 2)))
+                        (flush ""))
+                    (if (string= alignment "left")
+                        (progn
+                          (setq textposition start)
+                          (setq flush "[left]"))
+                      (if (string= alignment "right")
+                          (progn
+                            (setq textposition end)
+                            (setq flush "[right]"))))
+                    (setq tasks
+                          (format "%s  \\gantttask{%s}{%s}{%d}{%d}{%d}{%s}\n"
+                                  tasks label task start end textposition flush))
+                    (setq ntasks (+ 1 ntasks))
+                    (if (> end projecttime)
+                        (setq projecttime end)))
+                (if (string= type "milestone")
+                    (progn
+                      (setq milestones
+                            (format
+                             "%s  \\ganttmilestone{$\\begin{array}{c}\\mbox{%s}\\\\ \\mbox{%s}\\end{array}$}{%d}\n"
+                             milestones label task start))
+                      (setq nmilestones (+ 1 nmilestones)))
+                  (if (string= type "date")
+                      (setq dates (format "%s  \\ganttdateline{%s}{%d}\n"
+                                          dates label start))
+                    (message "Ignoring entry with type %s\n" type)))))
+          (message "Ignoring non-list entry %s\n" entry)) ; end if list entry
+        (setq entries (cdr entries))))  ; end while entries left
+    (format "\\pgfdeclarelayer{background}
+  \\pgfdeclarelayer{foreground}
+  \\pgfsetlayers{background,foreground}
+  \\renewcommand{\\ganttprojecttime}{%d}
+  \\renewcommand{\\ganttntasks}{%d}
+  \\noindent
+  \\begin{tikzpicture}[y=-0.75cm,x=0.75\\textwidth]
+    \\begin{pgfonlayer}{background}
+      \\draw[very thin, red!10!white] (0,1+\\ganttntasks) grid [ystep=0.75cm,xstep=1/\\ganttprojecttime] (1,0);
+      \\draw[\\ganttdatelinecolour] (0,0) -- (1,0);
+      \\draw[\\ganttdatelinecolour] (0,1+\\ganttntasks) -- (1,1+\\ganttntasks);
+    \\end{pgfonlayer}
+  %s
+  %s
+  %s
+  \\end{tikzpicture}" projecttime ntasks tasks milestones dates))
+#+end_src
+
+* Available languages
+  :PROPERTIES:
+  :AUTHOR:   Bastien
+  :END:
+
+** From Org's core
+
+| Language   | Identifier | Language       | Identifier |
+|------------+------------+----------------+------------|
+| Asymptote  | asymptote  | Awk            | awk        |
+| Emacs Calc | calc       | C              | C          |
+| C++        | C++        | Clojure        | clojure    |
+| CSS        | css        | ditaa          | ditaa      |
+| Graphviz   | dot        | Emacs Lisp     | emacs-lisp |
+| gnuplot    | gnuplot    | Haskell        | haskell    |
+| Javascript | js         | LaTeX          | latex      |
+| Ledger     | ledger     | Lisp           | lisp       |
+| Lilypond   | lilypond   | MATLAB         | matlab     |
+| Mscgen     | mscgen     | Objective Caml | ocaml      |
+| Octave     | octave     | Org-mode       | org        |
+|            |            | Perl           | perl       |
+| Plantuml   | plantuml   | Python         | python     |
+| R          | R          | Ruby           | ruby       |
+| Sass       | sass       | Scheme         | scheme     |
+| GNU Screen | screen     | shell          | sh         |
+| SQL        | sql        | SQLite         | sqlite     |
+
+** From Org's contrib/babel/langs
+
+- ob-oz.el, by Torsten Anders and Eric Schulte
+- ob-fomus.el, by Torsten Anders