Now able to reference a table from an emacs-lisp src block.

Currently the only reference which is working is previous.

For an example try

: | 0.16 | eric | 0.12 |
: | 0.24 | 0.28 | 0.08 |
:
: #+begin_src emacs-lisp :var table=previous
: table
: #+end_src

litorgy/litorgy-lisp.el

@@ -39,8 +39,48 @@ function is called by `litorgy-execute-src-block'."
   (save-window-excursion
     (let ((vars (litorgy-reference-variables params))
           (print-level nil) (print-length nil) results)
+      (message "prefix")
+      (message (format "-%S-" body))
+      (message (format "%S" (stringp body)))
+      (message (format "vars = %S" vars))
+      (setq vars (mapcar (lambda (pair)
+                         (list (intern (car pair))
+                               (mapcar (lambda (row)
+                                         (mapcar #'litorgy-read-cell row))
+                                       (cdr pair))))
+                       vars))
+      (message (format "let = %S" vars))
+      ;; need to find a way of assigning the variables in vars for the
+      ;; context in which body is executed
       (message "executing emacs-lisp code block...")
-      (format "%S" (eval (read body))))))
+      (format "%S"
+              (eval `(let ,(mapcar (lambda (var)
+                                     `(,(car var) ',(cdr var)))
+                                   vars)
+                       (message "inside")
+                       (message (format "- %S -" table))
+                       (message (format "- %S -" body))
+                       ,(read body)))))))
+
+(defun litorgy-read-cell (cell)
+  "Convert the string value of CELL to a number if appropriate.
+Otherwise if cell looks like a list (meaning it starts with a
+'(') then read it as lisp, otherwise return it unmodified as a
+string.
+
+This is taken almost directly from `org-read-prop'."
+  (if (and (stringp cell) (not (equal cell "")))
+      (let ((out (string-to-number cell)))
+	(if (equal out 0)
+	    (if (or (equal "(" (substring cell 0 1))
+                    (equal "'" (substring cell 0 1)))
+                (read cell)
+	      (if (string-match "^\\(+0\\|-0\\|0\\)$" cell)
+		  0
+		(progn (set-text-properties 0 (length cell) nil cell)
+		       cell)))
+	  out))
+    cell))
 
 (provide 'litorgy-lisp)
 ;;; litorgy-lisp.el ends here

litorgy/litorgy-reference.el

@@ -57,7 +57,7 @@
   "Takes a parameter alist, and return an alist of variable
 names, and the string representation of the related value."
   (mapcar #'litorgy-reference-parse
-   (delq nil (mapcar (lambda (pair) (if (= (car pair) :var) (cdr pair))) params))))
+   (delq nil (mapcar (lambda (pair) (if (eq (car pair) :var) (cdr pair))) params))))
 
 (defun litorgy-reference-parse (reference)
   "Parse a reference to an external resource returning a list
@@ -65,19 +65,31 @@ with two elements.  The first element of the list will be the
 name of the variable, and the second will be an emacs-lisp
 representation of the value of the variable."
   (save-excursion
-    (if (string-match "(.+)=(.+)" reference)
-      (let ((var (match-string 1 reference))
-            (ref (match-string 2 reference)))
-        (when (string-match "(.+):(.+)" reference)
-          (find-file (match-string 1 reference))
-          (setf ref (match-string 2 reference)))
-        ;; follow the reference in the current file
-        (case ref
-          ("previous"
-           )
-          ("next")
-          (t ))
-        ))))
+    (if (string-match "\\(.+\\)=\\(.+\\)" reference)
+        (let ((var (match-string 1 reference))
+              (ref (match-string 2 reference))
+              direction)
+          (when (string-match "\\(.+\\):\\(.+\\)" reference)
+            (find-file (match-string 1 reference))
+            (setf ref (match-string 2 reference)))
+          (cons var (progn
+                      (cond ;; follow the reference in the current file
+                       ((string= ref "previous") (setq direction -1))
+                       ((string= ref "next") (setq direction 1))
+                       (t
+                        (goto-char (point-min))
+                        (setq direction 1)
+                        (unless (re-search-forward
+                                 (concat "^#\\+TBLNAME:[ \t]*" (regexp-quote ref) "[ \t]*$") nil t)
+                          (setq id-loc (org-id-find name-or-id 'marker)
+                                buffer (marker-buffer id-loc)
+                                loc (marker-position id-loc))
+                          (move-marker id-loc nil))))
+                      (while (not (org-at-table-p))
+                        (forward-line direction)
+                        (if (or (= (point) (point-min)) (= (point) (point-max)))
+                            (error "no table found")))
+                      (org-table-to-lisp)))))))
 
 (provide 'litorgy-reference)
 ;;; litorgy-reference.el ends here