From 2af1360042b12ebbc61bc05bc045e418a690f99e Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 03:49:44 -0400
Subject: Rewrote ldg-regex with a macro (for simplicity)

---
 lisp/ldg-post.el  |  14 +-
 lisp/ldg-regex.el | 404 ++++++++++++++++++++++++++++++++----------------------
 2 files changed, 250 insertions(+), 168 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index 30edd035..c762e51b 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -50,7 +50,7 @@ to choose from."
 	 (account-len (length account))
 	 (pos (point)))
     (goto-char (line-beginning-position))
-    (when (re-search-forward ledger-regex-post-line (line-end-position) t)
+    (when (re-search-forward ledger-post-line-regexp (line-end-position) t)
       (let ((existing-len (length (match-string 3))))
 	(goto-char (match-beginning 3))
 	(delete-region (match-beginning 3) (match-end 3))
@@ -76,13 +76,13 @@ to choose from."
     (goto-char beg)
     (when (< end (line-end-position))
       (goto-char (line-beginning-position))
-      (if (looking-at ledger-regex-post-line)
+      (if (looking-at ledger-post-line-regexp)
 	  (ledger-post-align-amount)))))
 
 (defun ledger-post-edit-amount ()
   (interactive)
   (goto-char (line-beginning-position))
-  (when (re-search-forward ledger-regex-post-line (line-end-position) t)
+  (when (re-search-forward ledger-post-line-regexp (line-end-position) t)
     (goto-char (match-end 3))
     (when (re-search-forward "[-.,0-9]+" (line-end-position) t)
       (let ((val (match-string 0)))
@@ -96,16 +96,16 @@ to choose from."
 (defun ledger-post-prev-xact ()
   (interactive)
   (backward-paragraph)
-  (when (re-search-backward ledger-regex-xact-line nil t)
+  (when (re-search-backward ledger-xact-line-regexp nil t)
     (goto-char (match-beginning 0))
-    (re-search-forward ledger-regex-post-line)
+    (re-search-forward ledger-post-line-regexp)
     (goto-char (match-end 3))))
 
 (defun ledger-post-next-xact ()
   (interactive)
-  (when (re-search-forward ledger-regex-xact-line nil t)
+  (when (re-search-forward ledger-xact-line-regexp nil t)
     (goto-char (match-beginning 0))
-    (re-search-forward ledger-regex-post-line)
+    (re-search-forward ledger-post-line-regexp)
     (goto-char (match-end 3))))
 
 (defun ledger-post-setup ()
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 14c41f63..0db19197 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -1,167 +1,249 @@
 (require 'rx)
 
-(defconst ledger-regex-date
-  (let ((sep '(or ?- (any ?. ?/))))	; can't do (any ?- ?. ?/) due to bug
-    (rx (group
-	 (and (? (= 4 num)
-		 (eval sep))
-	      (and num (? num))
-	      (eval sep)
-	      (and num (? num))))))
+(eval-when-compile
+  (require 'cl))
+
+(defmacro ledger-define-regexp (name regex docs &rest args)
+  "Simplify the creation of a Ledger regex and helper functions."
+  (let ((defs
+	  (list
+	   `(defconst
+	      ,(intern (concat "ledger-" (symbol-name name) "-regexp"))
+	      ,(eval regex))))
+	(addend 0) last-group)
+    (if (null args)
+	(progn
+	  (nconc
+	   defs
+	   (list
+	    `(defconst
+	       ,(intern
+		 (concat "ledger-regex-" (symbol-name name) "-group"))
+	       1)))
+	  (nconc
+	   defs
+	   (list
+	    `(defconst
+	       ,(intern (concat "ledger-regex-" (symbol-name name)
+				"-group--count"))
+	       1)))
+	  (nconc
+	   defs
+	   (list
+	    `(defmacro
+	       ,(intern (concat "ledger-regex-" (symbol-name name)))
+	       (&optional string)
+	       ,(format "Return the match string for the %s" name)
+	       (match-string
+		,(intern (concat "ledger-regex-" (symbol-name name)
+				 "-group"))
+		string)))))
+      
+      (dolist (arg args)
+	(let (var grouping target)
+	  (if (symbolp arg)
+	      (setq var arg target arg)
+	    (assert (listp arg))
+	    (if (= 2 (length arg))
+		(setq var (car arg)
+		      target (cadr arg))
+	      (setq var (car arg)
+		    grouping (cadr arg)
+		    target (caddr arg))))
+
+	  (if (and last-group
+		   (not (eq last-group (or grouping target))))
+	      (incf addend
+		    (symbol-value
+		     (intern-soft (concat "ledger-regex-"
+					  (symbol-name last-group)
+					  "-group--count")))))
+	  (nconc
+	   defs
+	   (list
+	    `(defconst
+	       ,(intern (concat "ledger-regex-" (symbol-name name)
+				"-group-" (symbol-name var)))
+	       ,(+ addend
+		   (symbol-value
+		    (intern-soft
+		     (if grouping
+			 (concat "ledger-regex-" (symbol-name grouping)
+				 "-group-" (symbol-name target))
+		       (concat "ledger-regex-" (symbol-name target)
+			       "-group"))))))))
+	  (nconc
+	   defs
+	   (list
+	    `(defmacro
+	       ,(intern (concat "ledger-regex-" (symbol-name name)
+				"-" (symbol-name var)))
+	       (&optional string)
+	       ,(format "Return the sub-group match for the %s %s."
+			name var)
+	       (match-string
+		,(intern (concat "ledger-regex-" (symbol-name name)
+				 "-group-" (symbol-name var)))
+		string))))
+
+	  (setq last-group (or grouping target))))
+
+      (nconc defs
+	     (list
+	      `(defconst ,(intern (concat "ledger-regex-" (symbol-name name)
+					  "-group--count"))
+		 ,(length args)))))
+
+    (cons 'progn defs)))
+
+(put 'ledger-define-regexp 'lisp-indent-function 2)
+
+(ledger-define-regexp date
+    (let ((sep '(or ?- (any ?. ?/))))	; can't do (any ?- ?. ?/) due to bug
+      (rx (group
+	   (and (? (= 4 num)
+		   (eval sep))
+		(and num (? num))
+		(eval sep)
+		(and num (? num))))))
   "Match a single date, in its 'written' form.")
 
-(defconst ledger-regex-date-group 1)
-(defconst ledger-regex-date-group--count 1)
-
-(defconst ledger-regex-full-date
-  (macroexpand
-   `(rx (and (regexp ,ledger-regex-date)
-	     (? (and ?= (regexp ,ledger-regex-date))))))
-  "Match a compound date, of the form ACTUAL=EFFECTIVE")
-
-(defconst ledger-regex-full-date-group-actual
-  ledger-regex-date-group)
-(defconst ledger-regex-full-date-group-effective
-  (+ ledger-regex-date-group--count
-     ledger-regex-date-group))
-(defconst ledger-regex-full-date-group--count
-  (* 2 ledger-regex-date-group--count))
-
-(defconst ledger-regex-state
-  (rx (group (any ?! ?*))))
-
-(defconst ledger-regex-state-group 1)
-(defconst ledger-regex-state-group--count 1)
-
-(defconst ledger-regex-code
-  (rx (and ?\( (group (+? (not (any ?\))))) ?\))))
-
-(defconst ledger-regex-code-group 1)
-(defconst ledger-regex-code-group--count 1)
-
-(defconst ledger-regex-long-space
-  (rx (and (*? space)
-	   (or (and ?  (or ?  ?\t)) ?\t))))
-
-(defconst ledger-regex-note
-  (rx (group (+ nonl))))
-
-(defconst ledger-regex-note-group 1)
-(defconst ledger-regex-note-group--count 1)
-
-(defconst ledger-regex-end-note
-  (macroexpand `(rx (and (regexp ,ledger-regex-long-space) ?\;
-			 (regexp ,ledger-regex-note)))))
-
-(defconst ledger-regex-end-note-group
-  ledger-regex-note-group)
-(defconst ledger-regex-end-note-group--count
-  ledger-regex-note-group--count)
-
-(defconst ledger-regex-full-note
-  (macroexpand `(rx (and line-start (+ space)
-			 ?\; (regexp ,ledger-regex-note)))))
-
-(defconst ledger-regex-full-note-group
-  ledger-regex-note-group)
-(defconst ledger-regex-full-note-group--count
-  ledger-regex-note-group--count)
-
-(defconst ledger-regex-xact-line
-  (macroexpand
-   `(rx (and line-start
-	     (regexp ,ledger-regex-full-date)
-	     (? (and (+ space) (regexp ,ledger-regex-state)))
-	     (? (and (+ space) (regexp ,ledger-regex-code)))
-	     (+ space) (+? nonl)
-	     (? (regexp ,ledger-regex-end-note))
-	     line-end))))
-
-(defconst ledger-regex-xact-line-group-actual-date
-  ledger-regex-full-date-group-actual)
-(defconst ledger-regex-xact-line-group-effective-date
-  ledger-regex-full-date-group-effective)
-(defconst ledger-regex-xact-line-group-state
-  (+ ledger-regex-full-date-group--count
-     ledger-regex-state-group))
-(defconst ledger-regex-xact-line-group-code
-  (+ ledger-regex-full-date-group--count
-     ledger-regex-state-group--count
-     ledger-regex-code-group))
-(defconst ledger-regex-xact-line-group-note
-  (+ ledger-regex-full-date-group--count
-     ledger-regex-state-group--count
-     ledger-regex-code-group--count
-     ledger-regex-note-group))
-(defconst ledger-regex-full-note-group--count
-  (+ ledger-regex-full-date-group--count
-     ledger-regex-state-group--count
-     ledger-regex-code-group--count
-     ledger-regex-note-group--count))
-
-(defun ledger-regex-xact-line-actual-date
-  (&optional string)
-  (match-string ledger-regex-xact-line-group-actual-date string))
-
-(defconst ledger-regex-account
-  (rx (group (and (not (any ?:)) (*? nonl)))))
-
-(defconst ledger-regex-full-account
-  (macroexpand
-   `(rx (and (group (? (any ?\[ ?\))))
-	     (regexp ,ledger-regex-account)
-	     (? (any ?\] ?\)))))))
-
-(defconst ledger-regex-commodity
-  (rx (or (and ?\" (+ (not (any ?\"))) ?\")
-	  (not (any space ?\n
-		    digit
-		    ?- ?\[ ?\]
-		    ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?=
-		    ?\< ?\> ?\{ ?\} ?\( ?\) ?@)))))
-
-(defconst ledger-regex-amount
-  (rx (and (? ?-)
-	   (and (+ digit)
-		(*? (and (any ?. ?,) (+ digit))))
-	   (? (and (any ?. ?,) (+ digit))))))
-
-(defconst ledger-regex-commoditized-amount
-  (macroexpand
-   `(rx (or (and (regexp ,ledger-regex-commodity)
-		 (*? space)
-		 (regexp ,ledger-regex-amount))
-	    (and (regexp ,ledger-regex-amount)
-		 (*? space)
-		 (regexp ,ledger-regex-commodity))))))
-
-(defconst ledger-regex-commodity-annotations
-  (macroexpand
-   `(rx (* (+ space)
-	   (or (and ?\{ (regexp ,ledger-regex-commoditized-amount) ?\})
-	       (and ?\[ (regexp ,ledger-regex-date) ?\])
-	       (and ?\( (not (any ?\))) ?\)))))))
-
-(defconst ledger-regex-cost
-  (macroexpand
-   `(rx (and (or "@" "@@") (+ space)
-	     (regexp ,ledger-regex-commoditized-amount)))))
-
-(defconst ledger-regex-balance-assertion
-  (macroexpand
-   `(rx (and ?= (+ space)
-	     (regexp ,ledger-regex-commoditized-amount)))))
-
-(defconst ledger-regex-full-amount
-  (macroexpand `(rx (group (+? (not (any ?\;)))))))
-
-(defconst ledger-regex-post-line
-  (macroexpand
-   `(rx (and line-start
-	     (? (and (+ space) (regexp ,ledger-regex-state)))
-	     (+ space) (regexp ,ledger-regex-full-account)
-	     (+ space) (regexp ,ledger-regex-full-amount)
-	     (? (regexp ,ledger-regex-end-note))
-	     line-end))))
+(ledger-define-regexp full-date
+    (macroexpand
+     `(rx (and (regexp ,ledger-date-regexp)
+	       (? (and ?= (regexp ,ledger-date-regexp))))))
+  "Match a compound date, of the form ACTUAL=EFFECTIVE"
+  (actual date)
+  (effective date))
+
+(ledger-define-regexp state
+    (rx (group (any ?! ?*)))
+  "Match a transaction or posting's \"state\" character.")
+
+(ledger-define-regexp code
+    (rx (and ?\( (group (+? (not (any ?\))))) ?\)))
+  "Match the transaction code.")
+
+(ledger-define-regexp long-space
+    (rx (and (*? space)
+	     (or (and ?  (or ?  ?\t)) ?\t)))
+  "Match a \"long space\".")
+
+(ledger-define-regexp note
+    (rx (group (+ nonl)))
+  "")
+
+(ledger-define-regexp end-note
+    (macroexpand
+     `(rx (and (regexp ,ledger-long-space-regexp) ?\;
+	       (regexp ,ledger-note-regexp))))
+  "")
+
+(ledger-define-regexp full-note
+    (macroexpand
+     `(rx (and line-start (+ space)
+	       ?\; (regexp ,ledger-note-regexp))))
+  "")
+
+(ledger-define-regexp xact-line
+    (macroexpand
+     `(rx (and line-start
+	       (regexp ,ledger-full-date-regexp)
+	       (? (and (+ space) (regexp ,ledger-state-regexp)))
+	       (? (and (+ space) (regexp ,ledger-code-regexp)))
+	       (+ space) (+? nonl)
+	       (? (regexp ,ledger-end-note-regexp))
+	       line-end)))
+  "Match a transaction's first line (and optional notes)."
+  (actual-date full-date actual)
+  (effective-date full-date effective)
+  state
+  code
+  (note end-note))
+
+(ledger-define-regexp account
+    (rx (group (and (not (any ?:)) (*? nonl))))
+  "")
+
+(ledger-define-regexp account-kind
+    (rx (group (? (any ?\[ ?\)))))
+  "")
+
+(ledger-define-regexp full-account
+    (macroexpand
+     `(rx (and (regexp ,ledger-account-kind-regexp)
+	       (regexp ,ledger-account-regexp)
+	       (? (any ?\] ?\))))))
+  ""
+  (kind account-kind)
+  (name account))
+
+(ledger-define-regexp commodity
+    (rx (group
+	 (or (and ?\" (+ (not (any ?\"))) ?\")
+	     (not (any space ?\n
+		       digit
+		       ?- ?\[ ?\]
+		       ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?=
+		       ?\< ?\> ?\{ ?\} ?\( ?\) ?@)))))
+  "")
+
+(ledger-define-regexp amount
+    (rx (group
+	 (and (? ?-)
+	      (and (+ digit)
+		   (*? (and (any ?. ?,) (+ digit))))
+	      (? (and (any ?. ?,) (+ digit))))))
+  "")
+
+(ledger-define-regexp commoditized-amount
+    (macroexpand
+     `(rx (group
+	   (or (and (regexp ,ledger-commodity-regexp)
+		    (*? space)
+		    (regexp ,ledger-amount-regexp))
+	       (and (regexp ,ledger-amount-regexp)
+		    (*? space)
+		    (regexp ,ledger-commodity-regexp))))))
+  "")
+
+(ledger-define-regexp commodity-annotations
+    (macroexpand
+     `(rx (* (+ space)
+	     (or (and ?\{ (regexp ,ledger-commoditized-amount-regexp) ?\})
+		 (and ?\[ (regexp ,ledger-date-regexp) ?\])
+		 (and ?\( (not (any ?\))) ?\))))))
+  "")
+
+(ledger-define-regexp cost
+    (macroexpand
+     `(rx (and (or "@" "@@") (+ space)
+	       (regexp ,ledger-commoditized-amount-regexp))))
+  "")
+
+(ledger-define-regexp balance-assertion
+    (macroexpand
+     `(rx (and ?= (+ space)
+	       (regexp ,ledger-commoditized-amount-regexp))))
+  "")
+
+(ledger-define-regexp full-amount
+    (macroexpand `(rx (group (+? (not (any ?\;))))))
+  "")
+
+(ledger-define-regexp post-line
+    (macroexpand
+     `(rx (and line-start
+	       (? (and (+ space) (regexp ,ledger-state-regexp)))
+	       (+ space) (regexp ,ledger-full-account-regexp)
+	       (+ space) (regexp ,ledger-full-amount-regexp)
+	       (? (regexp ,ledger-end-note-regexp))
+	       line-end)))
+  ""
+  state
+  (account-kind full-account kind)
+  (account-name full-account name)
+  (amount full-amount)
+  (note end-note))
 
 (provide 'ldg-regex)
-- 
cgit v1.2.3


From 2f2340d0ac1df4d911c58b68d48e88938bd7e862 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 22:30:42 -0400
Subject: Fixes to ledger-mode regexps

---
 lisp/ldg-regex.el | 37 +++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 18 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 0db19197..15226ef1 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -125,7 +125,7 @@
   "Match the transaction code.")
 
 (ledger-define-regexp long-space
-    (rx (and (*? space)
+    (rx (and (*? blank)
 	     (or (and ?  (or ?  ?\t)) ?\t)))
   "Match a \"long space\".")
 
@@ -141,7 +141,7 @@
 
 (ledger-define-regexp full-note
     (macroexpand
-     `(rx (and line-start (+ space)
+     `(rx (and line-start (+ blank)
 	       ?\; (regexp ,ledger-note-regexp))))
   "")
 
@@ -149,9 +149,9 @@
     (macroexpand
      `(rx (and line-start
 	       (regexp ,ledger-full-date-regexp)
-	       (? (and (+ space) (regexp ,ledger-state-regexp)))
-	       (? (and (+ space) (regexp ,ledger-code-regexp)))
-	       (+ space) (+? nonl)
+	       (? (and (+ blank) (regexp ,ledger-state-regexp)))
+	       (? (and (+ blank) (regexp ,ledger-code-regexp)))
+	       (+ blank) (+? nonl)
 	       (? (regexp ,ledger-end-note-regexp))
 	       line-end)))
   "Match a transaction's first line (and optional notes)."
@@ -162,11 +162,11 @@
   (note end-note))
 
 (ledger-define-regexp account
-    (rx (group (and (not (any ?:)) (*? nonl))))
+    (rx (group (and (not (any blank ?\[ ?\( ?: ?\;)) (*? nonl))))
   "")
 
 (ledger-define-regexp account-kind
-    (rx (group (? (any ?\[ ?\)))))
+    (rx (group (? (any ?\[ ?\())))
   "")
 
 (ledger-define-regexp full-account
@@ -181,7 +181,7 @@
 (ledger-define-regexp commodity
     (rx (group
 	 (or (and ?\" (+ (not (any ?\"))) ?\")
-	     (not (any space ?\n
+	     (not (any blank ?\n
 		       digit
 		       ?- ?\[ ?\]
 		       ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?=
@@ -200,16 +200,16 @@
     (macroexpand
      `(rx (group
 	   (or (and (regexp ,ledger-commodity-regexp)
-		    (*? space)
+		    (*? blank)
 		    (regexp ,ledger-amount-regexp))
 	       (and (regexp ,ledger-amount-regexp)
-		    (*? space)
+		    (*? blank)
 		    (regexp ,ledger-commodity-regexp))))))
   "")
 
 (ledger-define-regexp commodity-annotations
     (macroexpand
-     `(rx (* (+ space)
+     `(rx (* (+ blank)
 	     (or (and ?\{ (regexp ,ledger-commoditized-amount-regexp) ?\})
 		 (and ?\[ (regexp ,ledger-date-regexp) ?\])
 		 (and ?\( (not (any ?\))) ?\))))))
@@ -217,13 +217,13 @@
 
 (ledger-define-regexp cost
     (macroexpand
-     `(rx (and (or "@" "@@") (+ space)
+     `(rx (and (or "@" "@@") (+ blank)
 	       (regexp ,ledger-commoditized-amount-regexp))))
   "")
 
 (ledger-define-regexp balance-assertion
     (macroexpand
-     `(rx (and ?= (+ space)
+     `(rx (and ?= (+ blank)
 	       (regexp ,ledger-commoditized-amount-regexp))))
   "")
 
@@ -233,16 +233,17 @@
 
 (ledger-define-regexp post-line
     (macroexpand
-     `(rx (and line-start
-	       (? (and (+ space) (regexp ,ledger-state-regexp)))
-	       (+ space) (regexp ,ledger-full-account-regexp)
-	       (+ space) (regexp ,ledger-full-amount-regexp)
+     `(rx (and line-start (+ blank)
+	       (? (and (regexp ,ledger-state-regexp) (* blank)))
+	       (regexp ,ledger-full-account-regexp)
+	       (? (and (regexp ,ledger-long-space-regexp)
+		       (regexp ,ledger-full-amount-regexp)))
 	       (? (regexp ,ledger-end-note-regexp))
 	       line-end)))
   ""
   state
   (account-kind full-account kind)
-  (account-name full-account name)
+  (account full-account name)
   (amount full-amount)
   (note end-note))
 
-- 
cgit v1.2.3


From fff15425d8fa94b1e74a61e4a3551efb69cb737b Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 22:31:28 -0400
Subject: lisp/ledger.el is now deprecated (until release)

The new code, still under development, starts in ldg-new.el.  When it is
ready to replace the old code, it will be renamed to ledger.el.
---
 lisp/ledger.el | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lisp')

diff --git a/lisp/ledger.el b/lisp/ledger.el
index 9fa28781..0aff5eaf 100644
--- a/lisp/ledger.el
+++ b/lisp/ledger.el
@@ -4,7 +4,7 @@
 
 ;; Emacs Lisp Archive Entry
 ;; Filename: ledger.el
-;; Version: 3.0
+;; Version: 2.6.3
 ;; Date: Fri 18-Jul-2008
 ;; Keywords: data
 ;; Author: John Wiegley (johnw AT gnu DOT org)
-- 
cgit v1.2.3


From eb99efd2dd3738126ba285ba48c022425ae6d5dd Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 22:31:46 -0400
Subject: Cleanup the ldg-post code a little bit

---
 lisp/ldg-post.el | 103 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 75 insertions(+), 28 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index c762e51b..2d7a0e05 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -9,51 +9,70 @@
   :type 'boolean
   :group 'ledger-post)
 
-(declare-function iswitchb-read-buffer "iswitchb"
-                  (prompt &optional default require-match start matches-set))
-(defvar iswitchb-temp-buflist)
+(defcustom ledger-post-amount-alignment-column 52
+  "If non-nil, ."
+  :type 'integer
+  :group 'ledger-post)
 
-(defvar ledger-post-current-list nil)
+(defcustom ledger-post-use-iswitchb nil
+  "If non-nil, ."
+  :type 'boolean
+  :group 'ledger-post)
 
-(defun ledger-post-find-all ()
+(defcustom ledger-post-use-ido nil
+  "If non-nil, ."
+  :type 'boolean
+  :group 'ledger-post)
+
+(defun ledger-post-all-accounts ()
   (let ((origin (point))
 	(ledger-post-list nil)
-	account-path elements)
+	account elements)
     (save-excursion
       (goto-char (point-min))
-      (while (re-search-forward
-	      "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)" nil t)
+      (while (re-search-forward ledger-post-line-regexp nil t)
 	(unless (and (>= origin (match-beginning 0))
 		     (< origin (match-end 0)))
-	  (setq account-path (match-string-no-properties 2))
-	  (unless (string-match "\\`\\s-*;" account-path)
-	    (add-to-list 'ledger-post-list account-path))))
-      (setq ledger-post-current-list
-	    (nreverse ledger-post-list)))))
+	  (add-to-list 'ledger-post-list (ledger-regex-post-line-account))))
+      (nreverse ledger-post-list))))
+
+(declare-function iswitchb-read-buffer "iswitchb"
+                  (prompt &optional default require-match start matches-set))
+(defvar iswitchb-temp-buflist)
 
 (defun ledger-post-completing-read (prompt choices)
   "Use iswitchb as a completing-read replacement to choose from choices.
 PROMPT is a string to prompt with.  CHOICES is a list of strings
 to choose from."
-  (let* ((iswitchb-use-virtual-buffers nil)
-	 (iswitchb-make-buflist-hook
-	  (lambda ()
-	    (setq iswitchb-temp-buflist choices))))
-    (iswitchb-read-buffer prompt)))
+  (cond
+   (ledger-post-use-iswitchb
+    (let* ((iswitchb-use-virtual-buffers nil)
+	   (iswitchb-make-buflist-hook
+	    (lambda ()
+	      (setq iswitchb-temp-buflist choices))))
+      (iswitchb-read-buffer prompt)))
+   (ledger-post-use-ido
+    (ido-completing-read prompt choices))
+   (t
+    (completing-read prompt choices))))
+
+(defvar ledger-post-current-list nil)
 
 (defun ledger-post-pick-account ()
   (interactive)
   (let* ((account
-	  (ledger-post-completing-read "Account: "
-					  (or ledger-post-current-list
-					      (ledger-post-find-all))))
+	  (ledger-post-completing-read
+	   "Account: " (or ledger-post-current-list
+			   (setq ledger-post-current-list
+				 (ledger-post-all-accounts)))))
 	 (account-len (length account))
 	 (pos (point)))
     (goto-char (line-beginning-position))
     (when (re-search-forward ledger-post-line-regexp (line-end-position) t)
-      (let ((existing-len (length (match-string 3))))
-	(goto-char (match-beginning 3))
-	(delete-region (match-beginning 3) (match-end 3))
+      (let ((existing-len (length (ledger-regex-post-line-account))))
+	(goto-char (match-beginning ledger-regex-post-line-group-account))
+	(delete-region (match-beginning ledger-regex-post-line-group-account)
+		       (match-end ledger-regex-post-line-group-account))
 	(insert account)
 	(cond
 	 ((> existing-len account-len)
@@ -64,6 +83,33 @@ to choose from."
 		(delete-char 1)))))))
     (goto-char pos)))
 
+(defun ledger-align-amounts (&optional column)
+  "Align amounts in the current region.
+This is done so that the last digit falls in COLUMN, which defaults to 52."
+  (interactive "p")
+  (if (or (null column) (= column 1))
+      (setq column ledger-post-amount-alignment-column))
+  (save-excursion
+    (let* ((mark-first (< (mark) (point)))
+	   (begin (if mark-first (mark) (point)))
+	   (end (if mark-first (point-marker) (mark-marker)))
+	   offset)
+      (goto-char begin)
+      (while (setq offset (ledger-next-amount end))
+	(let ((col (current-column))
+	      (target-col (- column offset))
+	      adjust)
+	  (setq adjust (- target-col col))
+	  (if (< col target-col)
+	      (insert (make-string (- target-col col) ? ))
+	    (move-to-column target-col)
+	    (if (looking-back "  ")
+		(delete-char (- col target-col))
+	      (skip-chars-forward "^ \t")
+	      (delete-horizontal-space)
+	      (insert "  ")))
+	  (forward-line))))))
+
 (defun ledger-post-align-amount ()
   (interactive)
   (save-excursion
@@ -83,7 +129,7 @@ to choose from."
   (interactive)
   (goto-char (line-beginning-position))
   (when (re-search-forward ledger-post-line-regexp (line-end-position) t)
-    (goto-char (match-end 3))
+    (goto-char (match-end ledger-regex-post-line-group-account))
     (when (re-search-forward "[-.,0-9]+" (line-end-position) t)
       (let ((val (match-string 0)))
 	(goto-char (match-beginning 0))
@@ -99,14 +145,14 @@ to choose from."
   (when (re-search-backward ledger-xact-line-regexp nil t)
     (goto-char (match-beginning 0))
     (re-search-forward ledger-post-line-regexp)
-    (goto-char (match-end 3))))
+    (goto-char (match-end ledger-regex-post-line-group-account))))
 
 (defun ledger-post-next-xact ()
   (interactive)
   (when (re-search-forward ledger-xact-line-regexp nil t)
     (goto-char (match-beginning 0))
     (re-search-forward ledger-post-line-regexp)
-    (goto-char (match-end 3))))
+    (goto-char (match-end ledger-regex-post-line-group-account))))
 
 (defun ledger-post-setup ()
   (let ((map (current-local-map)))
@@ -115,7 +161,8 @@ to choose from."
     (define-key map [(control ?c) (control ?c)] 'ledger-post-pick-account)
     (define-key map [(control ?c) (control ?e)] 'ledger-post-edit-amount))
   (if ledger-post-auto-adjust-amounts
-      (add-hook 'after-change-functions 'ledger-post-maybe-align t t)))
+      (add-hook 'after-change-functions 'ledger-post-maybe-align t t))
+  (add-hook 'after-save-hook #'(lambda () (setq ledger-post-current-list nil))))
 
 (add-hook 'ledger-mode-hook 'ledger-post-setup)
 
-- 
cgit v1.2.3


From bd8e6686f2a1d837b3c4427dfce218b6e720268e Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 22:32:12 -0400
Subject: Broke up the old ledger.el into several submodules

---
 lisp/ldg-complete.el  | 155 +++++++++++++++++
 lisp/ldg-exec.el      |  33 ++++
 lisp/ldg-mode.el      | 114 +++++++++++++
 lisp/ldg-new.el       |  49 ++++++
 lisp/ldg-reconcile.el | 180 ++++++++++++++++++++
 lisp/ldg-register.el  |   7 +
 lisp/ldg-report.el    | 448 ++++++++++++++++++++++++++++++++++++++++++++++++++
 lisp/ldg-state.el     | 189 +++++++++++++++++++++
 lisp/ldg-xact.el      |  20 +++
 9 files changed, 1195 insertions(+)
 create mode 100644 lisp/ldg-complete.el
 create mode 100644 lisp/ldg-exec.el
 create mode 100644 lisp/ldg-mode.el
 create mode 100644 lisp/ldg-new.el
 create mode 100644 lisp/ldg-reconcile.el
 create mode 100644 lisp/ldg-register.el
 create mode 100644 lisp/ldg-report.el
 create mode 100644 lisp/ldg-state.el
 create mode 100644 lisp/ldg-xact.el

(limited to 'lisp')

diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el
new file mode 100644
index 00000000..cc2ac152
--- /dev/null
+++ b/lisp/ldg-complete.el
@@ -0,0 +1,155 @@
+;;(require 'esh-util)
+;;(require 'esh-arg)
+(require 'pcomplete)
+
+;; In-place completion support
+
+(defun ledger-thing-at-point ()
+  (let ((here (point)))
+    (goto-char (line-beginning-position))
+    (cond ((looking-at "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.+?)\\)?\\s-+")
+	   (goto-char (match-end 0))
+	   'entry)
+	  ((looking-at "^\\s-+\\([*!]\\s-+\\)?[[(]?\\(.\\)")
+	   (goto-char (match-beginning 2))
+	   'transaction)
+	  ((looking-at "^\\(sun\\|mon\\|tue\\|wed\\|thu\\|fri\\|sat\\)\\s-+")
+	   (goto-char (match-end 0))
+	   'entry)
+	  (t
+	   (ignore (goto-char here))))))
+
+(defun ledger-parse-arguments ()
+  "Parse whitespace separated arguments in the current region."
+  (let* ((info (save-excursion
+		 (cons (ledger-thing-at-point) (point))))
+	 (begin (cdr info))
+	 (end (point))
+	 begins args)
+    (save-excursion
+      (goto-char begin)
+      (when (< (point) end)
+	(skip-chars-forward " \t\n")
+	(setq begins (cons (point) begins))
+	(setq args (cons (buffer-substring-no-properties
+			  (car begins) end)
+			 args)))
+      (cons (reverse args) (reverse begins)))))
+
+(defun ledger-entries ()
+  (let ((origin (point))
+	entries-list)
+    (save-excursion
+      (goto-char (point-min))
+      (while (re-search-forward
+	      (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+		      "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)
+	(unless (and (>= origin (match-beginning 0))
+		     (< origin (match-end 0)))
+	  (setq entries-list (cons (match-string-no-properties 3)
+				   entries-list)))))
+    (pcomplete-uniqify-list (nreverse entries-list))))
+
+(defvar ledger-account-tree nil)
+
+(defun ledger-find-accounts ()
+  (let ((origin (point)) account-path elements)
+    (save-excursion
+      (setq ledger-account-tree (list t))
+      (goto-char (point-min))
+      (while (re-search-forward
+	      "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)" nil t)
+	(unless (and (>= origin (match-beginning 0))
+		     (< origin (match-end 0)))
+	  (setq account-path (match-string-no-properties 2))
+	  (setq elements (split-string account-path ":"))
+	  (let ((root ledger-account-tree))
+	    (while elements
+	      (let ((entry (assoc (car elements) root)))
+		(if entry
+		    (setq root (cdr entry))
+		  (setq entry (cons (car elements) (list t)))
+		  (nconc root (list entry))
+		  (setq root (cdr entry))))
+	      (setq elements (cdr elements)))))))))
+
+(defun ledger-accounts ()
+  (ledger-find-accounts)
+  (let* ((current (caar (ledger-parse-arguments)))
+	 (elements (and current (split-string current ":")))
+	 (root ledger-account-tree)
+	 (prefix nil))
+    (while (cdr elements)
+      (let ((entry (assoc (car elements) root)))
+	(if entry
+	    (setq prefix (concat prefix (and prefix ":")
+				 (car elements))
+		  root (cdr entry))
+	  (setq root nil elements nil)))
+      (setq elements (cdr elements)))
+    (and root
+	 (sort
+	  (mapcar (function
+		   (lambda (x)
+		     (let ((term (if prefix
+				     (concat prefix ":" (car x))
+				   (car x))))
+		       (if (> (length (cdr x)) 1)
+			   (concat term ":")
+			 term))))
+		  (cdr root))
+	  'string-lessp))))
+
+(defun ledger-complete-at-point ()
+  "Do appropriate completion for the thing at point"
+  (interactive)
+  (while (pcomplete-here
+	  (if (eq (save-excursion
+		    (ledger-thing-at-point)) 'entry)
+	      (if (null current-prefix-arg)
+		  (ledger-entries)  ; this completes against entry names
+		(progn
+		  (let ((text (buffer-substring (line-beginning-position)
+						(line-end-position))))
+		    (delete-region (line-beginning-position)
+				   (line-end-position))
+		    (condition-case err
+			(ledger-add-entry text t)
+		      ((error)
+		       (insert text))))
+		  (forward-line)
+		  (goto-char (line-end-position))
+		  (search-backward ";" (line-beginning-position) t)
+		  (skip-chars-backward " \t0123456789.,")
+		  (throw 'pcompleted t)))
+	    (ledger-accounts)))))
+
+(defun ledger-fully-complete-entry ()
+  "Do appropriate completion for the thing at point"
+  (interactive)
+  (let ((name (caar (ledger-parse-arguments)))
+	xacts)
+    (save-excursion
+      (when (eq 'entry (ledger-thing-at-point))
+	(when (re-search-backward
+	       (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+		       (regexp-quote name) "\\(\t\\|\n\\| [ \t]\\)") nil t)
+	  (forward-line)
+	  (while (looking-at "^\\s-+")
+	    (setq xacts (cons (buffer-substring-no-properties
+			       (line-beginning-position)
+			       (line-end-position))
+			      xacts))
+	    (forward-line))
+	  (setq xacts (nreverse xacts)))))
+    (when xacts
+      (save-excursion
+	(insert ?\n)
+	(while xacts
+	  (insert (car xacts) ?\n)
+	  (setq xacts (cdr xacts))))
+      (forward-line)
+      (goto-char (line-end-position))
+      (if (re-search-backward "\\(\t\\| [ \t]\\)" nil t)
+	  (goto-char (match-end 0))))))
+
diff --git a/lisp/ldg-exec.el b/lisp/ldg-exec.el
new file mode 100644
index 00000000..d740fccc
--- /dev/null
+++ b/lisp/ldg-exec.el
@@ -0,0 +1,33 @@
+(defgroup ledger-binary nil
+  "Interface to the Ledger command-line accounting program."
+  :group 'ledger)
+
+(defcustom ledger-binary-path "ledger"
+  "Path to the ledger executable."
+  :type 'file
+  :group 'ledger)
+
+(defvar ledger-delete-after nil)
+
+(defun ledger-run-ledger (buffer &rest args)
+  "run ledger with supplied arguments"
+  ;; Let's try again, just in case they moved it while we were sleeping.
+  (cond
+   ((null ledger-binary-path)
+    (error "The variable `ledger-binary-path' has not been set"))
+   (t
+    (let ((buf (current-buffer)))
+      (with-current-buffer buffer
+	(let ((coding-system-for-write 'utf-8)
+	      (coding-system-for-read 'utf-8))
+	  (apply #'call-process-region
+		 (append (list (point-min) (point-max)
+			       ledger-binary-path ledger-delete-after
+			       buf nil "-f" "-")
+			 args))))))))
+
+(defun ledger-run-ledger-and-delete (buffer &rest args)
+  (let ((ledger-delete-after t))
+    (apply #'ledger-run-ledger buffer args)))
+
+(provide 'ldg-exec)
diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
new file mode 100644
index 00000000..625d9f49
--- /dev/null
+++ b/lisp/ldg-mode.el
@@ -0,0 +1,114 @@
+(defcustom ledger-default-acct-transaction-indent "    "
+  "Default indentation for account transactions in an entry."
+  :type 'string
+  :group 'ledger)
+
+(defvar bold 'bold)
+(defvar ledger-font-lock-keywords
+  '(("\\(	\\|  \\|^\\)\\(;.*\\)" 2 font-lock-comment-face)
+    ("^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(	;\\|  ;\\|$\\)\\)" 2 bold)
+    ;;("^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([*].+?\\)\\(\\(	;\\|  ;\\|$\\)\\)"
+    ;; 2 font-lock-type-face)
+    ("^\\s-+\\([*]\\s-*\\)?\\(\\([[(]\\)?[^*:
+	]+?:[^]);
+	]+?\\([])]\\)?\\)\\(	\\|  \\|$\\)"
+     2 font-lock-keyword-face)
+    ("^\\([~=].+\\)" 1 font-lock-function-name-face)
+    ("^\\([A-Za-z]+ .+\\)" 1 font-lock-function-name-face))
+  "Expressions to highlight in Ledger mode.")
+
+(defvar ledger-mode-abbrev-table)
+
+;;;###autoload
+(define-derived-mode ledger-mode text-mode "Ledger"
+  "A mode for editing ledger data files."
+  (set (make-local-variable 'comment-start) " ; ")
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'indent-tabs-mode) nil)
+
+  (if (boundp 'font-lock-defaults)
+      (set (make-local-variable 'font-lock-defaults)
+	   '(ledger-font-lock-keywords nil t)))
+
+  (set (make-local-variable 'pcomplete-parse-arguments-function)
+       'ledger-parse-arguments)
+  (set (make-local-variable 'pcomplete-command-completion-function)
+       'ledger-complete-at-point)
+  (set (make-local-variable 'pcomplete-termination-string) "")
+
+  (let ((map (current-local-map)))
+    (define-key map [(control ?c) (control ?a)] 'ledger-add-entry)
+    (define-key map [(control ?c) (control ?d)] 'ledger-delete-current-entry)
+    (define-key map [(control ?c) (control ?y)] 'ledger-set-year)
+    (define-key map [(control ?c) (control ?m)] 'ledger-set-month)
+    (define-key map [(control ?c) (control ?c)] 'ledger-toggle-current)
+    (define-key map [(control ?c) (control ?e)] 'ledger-toggle-current-entry)
+    (define-key map [(control ?c) (control ?r)] 'ledger-reconcile)
+    (define-key map [(control ?c) (control ?s)] 'ledger-sort)
+    (define-key map [tab] 'pcomplete)
+    (define-key map [(control ?i)] 'pcomplete)
+    (define-key map [(control ?c) tab] 'ledger-fully-complete-entry)
+    (define-key map [(control ?c) (control ?i)] 'ledger-fully-complete-entry)))
+
+(defun ledger-time-less-p (t1 t2)
+  "Say whether time value T1 is less than time value T2."
+  (or (< (car t1) (car t2))
+      (and (= (car t1) (car t2))
+	   (< (nth 1 t1) (nth 1 t2)))))
+
+(defun ledger-time-subtract (t1 t2)
+  "Subtract two time values.
+Return the difference in the format of a time value."
+  (let ((borrow (< (cadr t1) (cadr t2))))
+    (list (- (car t1) (car t2) (if borrow 1 0))
+	  (- (+ (if borrow 65536 0) (cadr t1)) (cadr t2)))))
+
+(defun ledger-find-slot (moment)
+  (catch 'found
+    (ledger-iterate-entries
+     (function
+      (lambda (start date mark desc)
+	(if (ledger-time-less-p moment date)
+	    (throw 'found t)))))))
+
+(defun ledger-add-entry (entry-text &optional insert-at-point)
+  (interactive "sEntry: ")
+  (let* ((args (with-temp-buffer
+		 (insert entry-text)
+		 (eshell-parse-arguments (point-min) (point-max))))
+	 (ledger-buf (current-buffer))
+	 exit-code)
+    (unless insert-at-point
+      (let ((date (car args)))
+	(if (string-match "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)" date)
+	    (setq date
+		  (encode-time 0 0 0 (string-to-number (match-string 3 date))
+			       (string-to-number (match-string 2 date))
+			       (string-to-number (match-string 1 date)))))
+	(ledger-find-slot date)))
+    (save-excursion
+      (insert
+       (with-temp-buffer
+	 (setq exit-code
+	       (apply #'ledger-run-ledger ledger-buf "entry"
+		      (mapcar 'eval args)))
+	 (goto-char (point-min))
+	 (if (looking-at "Error: ")
+	     (error (buffer-string))
+	   (buffer-string)))
+       "\n"))))
+
+(defun ledger-current-entry-bounds ()
+  (save-excursion
+    (when (or (looking-at "^[0-9]")
+	      (re-search-backward "^[0-9]" nil t))
+      (let ((beg (point)))
+	(while (not (eolp))
+	  (forward-line))
+	(cons (copy-marker beg) (point-marker))))))
+
+(defun ledger-delete-current-entry ()
+  (interactive)
+  (let ((bounds (ledger-current-entry-bounds)))
+    (delete-region (car bounds) (cdr bounds))))
+
diff --git a/lisp/ldg-new.el b/lisp/ldg-new.el
new file mode 100644
index 00000000..fce25984
--- /dev/null
+++ b/lisp/ldg-new.el
@@ -0,0 +1,49 @@
+;;; ledger.el --- Helper code for use with the "ledger" command-line tool
+
+;; Copyright (C) 2003-2010 John Wiegley (johnw AT gnu DOT org)
+
+;; Emacs Lisp Archive Entry
+;; Filename: ledger.el
+;; Version: 3.0
+;; Date: Mon 12-Apr-2010
+;; Keywords: data
+;; Author: John Wiegley (johnw AT gnu DOT org)
+;; Maintainer: John Wiegley (johnw AT gnu DOT org)
+;; Description: Helper code for using my "ledger" command-line tool
+;; URL: http://www.newartisans.com/johnw/emacs.html
+;; Compatibility: Emacs22,Emacs23,Emacs24
+
+;; This file is not part of GNU Emacs.
+
+;; This 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 2, or (at your option) any later
+;; version.
+;;
+;; This 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., 59 Temple Place - Suite 330, Boston,
+;; MA 02111-1307, USA.
+
+;;; Commentary:
+
+(require 'ldg-post)
+
+(autoload #'ledger-texi-update-test "ldg-texi" nil t)
+(autoload #'ledger-texi-update-examples "ldg-texi" nil t)
+
+(defgroup ledger nil
+  "Interface to the Ledger command-line accounting program."
+  :group 'data)
+
+(defconst ledger-version "3.0"
+  "The version of ledger.el currently loaded")
+
+(provide 'ledger)
+
+;;; ledger.el ends here
diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el
new file mode 100644
index 00000000..e19e0705
--- /dev/null
+++ b/lisp/ldg-reconcile.el
@@ -0,0 +1,180 @@
+;; Reconcile mode
+
+(defvar ledger-buf nil)
+(defvar ledger-acct nil)
+
+(defun ledger-display-balance ()
+  (let ((buffer ledger-buf)
+	(account ledger-acct))
+    (with-temp-buffer
+      (let ((exit-code (ledger-run-ledger buffer "-C" "balance" account)))
+	(if (/= 0 exit-code)
+	    (message "Error determining cleared balance")
+	  (goto-char (1- (point-max)))
+	  (goto-char (line-beginning-position))
+	  (delete-horizontal-space)
+	  (message "Cleared balance = %s"
+		   (buffer-substring-no-properties (point)
+						   (line-end-position))))))))
+
+(defun ledger-reconcile-toggle ()
+  (interactive)
+  (let ((where (get-text-property (point) 'where))
+	(account ledger-acct)
+	(inhibit-read-only t)
+	cleared)
+    (when (or (equal (car where) "<stdin>") (equal (car where) "/dev/stdin"))
+      (with-current-buffer ledger-buf
+	  (goto-char (cdr where))
+	(setq cleared (ledger-toggle-current 'pending)))
+      (if cleared
+	  (add-text-properties (line-beginning-position)
+			       (line-end-position)
+			       (list 'face 'bold))
+	(remove-text-properties (line-beginning-position)
+				(line-end-position)
+				(list 'face))))
+    (forward-line)))
+
+(defun ledger-reconcile-refresh ()
+  (interactive)
+  (let ((inhibit-read-only t)
+	(line (count-lines (point-min) (point))))
+    (erase-buffer)
+    (ledger-do-reconcile)
+    (set-buffer-modified-p t)
+    (goto-char (point-min))
+    (forward-line line)))
+
+(defun ledger-reconcile-refresh-after-save ()
+  (let ((buf (get-buffer "*Reconcile*")))
+    (if buf
+	(with-current-buffer buf
+	  (ledger-reconcile-refresh)
+	  (set-buffer-modified-p nil)))))
+
+(defun ledger-reconcile-add ()
+  (interactive)
+  (with-current-buffer ledger-buf
+    (call-interactively #'ledger-add-entry))
+  (ledger-reconcile-refresh))
+
+(defun ledger-reconcile-delete ()
+  (interactive)
+  (let ((where (get-text-property (point) 'where)))
+    (when (or (equal (car where) "<stdin>") (equal (car where) "/dev/stdin"))
+      (with-current-buffer ledger-buf
+	(goto-char (cdr where))
+	(ledger-delete-current-entry))
+      (let ((inhibit-read-only t))
+	(goto-char (line-beginning-position))
+	(delete-region (point) (1+ (line-end-position)))
+	(set-buffer-modified-p t)))))
+
+(defun ledger-reconcile-visit ()
+  (interactive)
+  (let ((where (get-text-property (point) 'where)))
+    (when (or (equal (car where) "<stdin>") (equal (car where) "/dev/stdin"))
+      (switch-to-buffer-other-window ledger-buf)
+      (goto-char (cdr where)))))
+
+(defun ledger-reconcile-save ()
+  (interactive)
+  (with-current-buffer ledger-buf
+    (save-buffer))
+  (set-buffer-modified-p nil)
+  (ledger-display-balance))
+
+(defun ledger-reconcile-quit ()
+  (interactive)
+  (kill-buffer (current-buffer)))
+
+(defun ledger-reconcile-finish ()
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (while (not (eobp))
+      (let ((where (get-text-property (point) 'where))
+	    (face  (get-text-property (point) 'face)))
+	(if (and (eq face 'bold)
+		 (or (equal (car where) "<stdin>") (equal (car where) "/dev/stdin")))
+	    (with-current-buffer ledger-buf
+	      (goto-char (cdr where))
+	      (ledger-toggle-current 'cleared))))
+      (forward-line 1)))
+  (ledger-reconcile-save))
+
+(defun ledger-do-reconcile ()
+  (let* ((buf ledger-buf)
+	 (account ledger-acct)
+	 (items
+	  (with-temp-buffer
+	    (let ((exit-code
+		   (ledger-run-ledger buf "--uncleared" "emacs" account)))
+	      (when (= 0 exit-code)
+		(goto-char (point-min))
+		(unless (eobp)
+		  (unless (looking-at "(")
+		    (error (buffer-string)))
+		  (read (current-buffer))))))))
+    (dolist (item items)
+      (let ((index 1))
+	(dolist (xact (nthcdr 5 item))
+	  (let ((beg (point))
+		(where
+		 (with-current-buffer buf
+		   (cons
+		    (nth 0 item)
+		    (if ledger-clear-whole-entries
+			(save-excursion
+			  (goto-line (nth 1 item))
+			  (point-marker))
+		      (save-excursion
+			(goto-line (nth 0 xact))
+			(point-marker)))))))
+	    (insert (format "%s %-30s %-25s %15s\n"
+			    (format-time-string "%m/%d" (nth 2 item))
+			    (nth 4 item) (nth 1 xact) (nth 2 xact)))
+	    (if (nth 3 xact)
+		(set-text-properties beg (1- (point))
+				     (list 'face 'bold
+					   'where where))
+	      (set-text-properties beg (1- (point))
+				   (list 'where where))))
+	  (setq index (1+ index)))))
+    (goto-char (point-min))
+    (set-buffer-modified-p nil)
+    (toggle-read-only t)))
+
+(defun ledger-reconcile (account)
+  (interactive "sAccount to reconcile: ")
+  (let ((buf (current-buffer))
+	(rbuf (get-buffer "*Reconcile*")))
+    (if rbuf
+	(kill-buffer rbuf))
+    (add-hook 'after-save-hook 'ledger-reconcile-refresh-after-save)
+    (with-current-buffer
+	(pop-to-buffer (get-buffer-create "*Reconcile*"))
+      (ledger-reconcile-mode)
+      (set (make-local-variable 'ledger-buf) buf)
+      (set (make-local-variable 'ledger-acct) account)
+      (ledger-do-reconcile))))
+
+(defvar ledger-reconcile-mode-abbrev-table)
+
+(define-derived-mode ledger-reconcile-mode text-mode "Reconcile"
+  "A mode for reconciling ledger entries."
+  (let ((map (make-sparse-keymap)))
+    (define-key map [(control ?m)] 'ledger-reconcile-visit)
+    (define-key map [return] 'ledger-reconcile-visit)
+    (define-key map [(control ?c) (control ?c)] 'ledger-reconcile-finish)
+    (define-key map [(control ?x) (control ?s)] 'ledger-reconcile-save)
+    (define-key map [(control ?l)] 'ledger-reconcile-refresh)
+    (define-key map [? ] 'ledger-reconcile-toggle)
+    (define-key map [?a] 'ledger-reconcile-add)
+    (define-key map [?d] 'ledger-reconcile-delete)
+    (define-key map [?n] 'next-line)
+    (define-key map [?p] 'previous-line)
+    (define-key map [?s] 'ledger-reconcile-save)
+    (define-key map [?q] 'ledger-reconcile-quit)
+    (use-local-map map)))
diff --git a/lisp/ldg-register.el b/lisp/ldg-register.el
new file mode 100644
index 00000000..8f0c8195
--- /dev/null
+++ b/lisp/ldg-register.el
@@ -0,0 +1,7 @@
+(require 'ldg-post)
+
+(defgroup ledger-register nil
+  ""
+  :group 'ledger)
+
+(provide 'ldg-register)
diff --git a/lisp/ldg-report.el b/lisp/ldg-report.el
new file mode 100644
index 00000000..6fc74f1d
--- /dev/null
+++ b/lisp/ldg-report.el
@@ -0,0 +1,448 @@
+(defcustom ledger-reports
+  '(("bal" "ledger -f %(ledger-file) bal")
+    ("reg" "ledger -f %(ledger-file) reg")
+    ("payee" "ledger -f %(ledger-file) reg -- %(payee)")
+    ("account" "ledger -f %(ledger-file) reg %(account)"))
+  "Definition of reports to run.
+
+Each element has the form (NAME CMDLINE).  The command line can
+contain format specifiers that are replaced with context sensitive
+information.  Format specifiers have the format '%(<name>)' where
+<name> is an identifier for the information to be replaced.  The
+`ledger-report-format-specifiers' alist variable contains a mapping
+from format specifier identifier to a lisp function that implements
+the substitution.  See the documentation of the individual functions
+in that variable for more information on the behavior of each
+specifier."
+  :type '(repeat (list (string :tag "Report Name")
+		       (string :tag "Command Line")))
+  :group 'ledger)
+
+(defcustom ledger-report-format-specifiers
+  '(("ledger-file" . ledger-report-ledger-file-format-specifier)
+    ("payee" . ledger-report-payee-format-specifier)
+    ("account" . ledger-report-account-format-specifier))
+  "Alist mapping ledger report format specifiers to implementing functions
+
+The function is called with no parameters and expected to return the
+text that should replace the format specifier."
+  :type 'alist
+  :group 'ledger)
+
+;;(define-key map [(control ?c) (control ?o) (control ?r)] 'ledger-report)
+;;(define-key map [(control ?c) (control ?o) (control ?g)] 'ledger-report-goto)
+;;(define-key map [(control ?c) (control ?o) (control ?a)] 'ledger-report-redo)
+;;(define-key map [(control ?c) (control ?o) (control ?s)] 'ledger-report-save)
+;;(define-key map [(control ?c) (control ?o) (control ?e)] 'ledger-report-edit)
+;;(define-key map [(control ?c) (control ?o) (control ?k)] 'ledger-report-kill)
+
+;; Ledger report mode
+
+(defvar ledger-report-buffer-name "*Ledger Report*")
+
+(defvar ledger-report-name nil)
+(defvar ledger-report-cmd nil)
+(defvar ledger-report-name-prompt-history nil)
+(defvar ledger-report-cmd-prompt-history nil)
+(defvar ledger-original-window-cfg nil)
+
+(defvar ledger-report-mode-abbrev-table)
+
+(define-derived-mode ledger-report-mode text-mode "Ledger-Report"
+  "A mode for viewing ledger reports."
+  (let ((map (make-sparse-keymap)))
+    (define-key map [? ] 'scroll-up)
+    (define-key map [backspace] 'scroll-down)
+    (define-key map [?r] 'ledger-report-redo)
+    (define-key map [?s] 'ledger-report-save)
+    (define-key map [?k] 'ledger-report-kill)
+    (define-key map [?e] 'ledger-report-edit)
+    (define-key map [?q] 'ledger-report-quit)
+    (define-key map [(control ?c) (control ?l) (control ?r)]
+      'ledger-report-redo)
+    (define-key map [(control ?c) (control ?l) (control ?S)]
+      'ledger-report-save)
+    (define-key map [(control ?c) (control ?l) (control ?k)]
+      'ledger-report-kill)
+    (define-key map [(control ?c) (control ?l) (control ?e)]
+      'ledger-report-edit)
+    (use-local-map map)))
+
+(defun ledger-report-read-name ()
+  "Read the name of a ledger report to use, with completion.
+
+The empty string and unknown names are allowed."
+  (completing-read "Report name: "
+		   ledger-reports nil nil nil
+		   'ledger-report-name-prompt-history nil))
+
+(defun ledger-report (report-name edit)
+  "Run a user-specified report from `ledger-reports'.
+
+Prompts the user for the name of the report to run.  If no name is
+entered, the user will be prompted for a command line to run.  The
+command line specified or associated with the selected report name
+is run and the output is made available in another buffer for viewing.
+If a prefix argument is given and the user selects a valid report
+name, the user is prompted with the corresponding command line for
+editing before the command is run.
+
+The output buffer will be in `ledger-report-mode', which defines
+commands for saving a new named report based on the command line
+used to generate the buffer, navigating the buffer, etc."
+  (interactive
+   (progn
+     (when (and (buffer-modified-p)
+		(y-or-n-p "Buffer modified, save it? "))
+       (save-buffer))
+     (let ((rname (ledger-report-read-name))
+	   (edit (not (null current-prefix-arg))))
+       (list rname edit))))
+  (let ((buf (current-buffer))
+	(rbuf (get-buffer ledger-report-buffer-name))
+	(wcfg (current-window-configuration)))
+    (if rbuf
+	(kill-buffer rbuf))
+    (with-current-buffer
+	(pop-to-buffer (get-buffer-create ledger-report-buffer-name))
+      (ledger-report-mode)
+      (set (make-local-variable 'ledger-buf) buf)
+      (set (make-local-variable 'ledger-report-name) report-name)
+      (set (make-local-variable 'ledger-original-window-cfg) wcfg)
+      (ledger-do-report (ledger-report-cmd report-name edit))
+      (shrink-window-if-larger-than-buffer)
+      (set-buffer-modified-p nil)
+      (setq buffer-read-only t)
+      (message "q to quit; r to redo; e to edit; k to kill; s to save; SPC and DEL to scroll"))))
+
+(defun string-empty-p (s)
+  "Check for the empty string."
+  (string-equal "" s))
+
+(defun ledger-report-name-exists (name)
+  "Check to see if the given report name exists.
+
+If name exists, returns the object naming the report, otherwise returns nil."
+  (unless (string-empty-p name)
+    (car (assoc name ledger-reports))))
+
+(defun ledger-reports-add (name cmd)
+  "Add a new report to `ledger-reports'."
+  (setq ledger-reports (cons (list name cmd) ledger-reports)))
+
+(defun ledger-reports-custom-save ()
+  "Save the `ledger-reports' variable using the customize framework."
+  (customize-save-variable 'ledger-reports ledger-reports))
+
+(defun ledger-report-read-command (report-cmd)
+  "Read the command line to create a report."
+  (read-from-minibuffer "Report command line: "
+			(if (null report-cmd) "ledger " report-cmd)
+			nil nil 'ledger-report-cmd-prompt-history))
+
+(defun ledger-report-ledger-file-format-specifier ()
+  "Substitute the full path to master or current ledger file
+
+The master file name is determined by the ledger-master-file buffer-local
+variable which can be set using file variables.  If it is set, it is used,
+otherwise the current buffer file is used."
+  (ledger-master-file))
+
+;; General helper functions
+
+(defvar ledger-master-file nil)
+
+(defun ledger-master-file ()
+  "Return the master file for a ledger file.
+
+The master file is either the file for the current ledger buffer or the
+file specified by the buffer-local variable ledger-master-file.  Typically
+this variable would be set in a file local variable comment block at the
+end of a ledger file which is included in some other file."
+  (if ledger-master-file
+      (expand-file-name ledger-master-file)
+    (buffer-file-name)))
+
+(defun ledger-read-string-with-default (prompt default)
+  (let ((default-prompt (concat prompt
+				(if default
+				    (concat " (" default "): ")
+				  ": "))))
+    (read-string default-prompt nil nil default)))
+
+(defun ledger-report-payee-format-specifier ()
+  "Substitute a payee name
+
+The user is prompted to enter a payee and that is substitued.  If
+point is in an entry, the payee for that entry is used as the
+default."
+  ;; It is intended copmletion should be available on existing
+  ;; payees, but the list of possible completions needs to be
+  ;; developed to allow this.
+  (ledger-read-string-with-default "Payee" (regexp-quote (ledger-entry-payee))))
+
+(defun ledger-report-account-format-specifier ()
+  "Substitute an account name
+
+The user is prompted to enter an account name, which can be any
+regular expression identifying an account.  If point is on an account
+transaction line for an entry, the full account name on that line is
+the default."
+  ;; It is intended completion should be available on existing account
+  ;; names, but it remains to be implemented.
+  (let* ((context (ledger-context-at-point))
+	 (default
+	  (if (eq (ledger-context-line-type context) 'acct-transaction)
+	      (regexp-quote (ledger-context-field-value context 'account))
+	    nil)))
+    (ledger-read-string-with-default "Account" default)))
+
+(defun ledger-report-expand-format-specifiers (report-cmd)
+  (let ((expanded-cmd report-cmd))
+    (while (string-match "%(\\([^)]*\\))" expanded-cmd)
+      (let* ((specifier (match-string 1 expanded-cmd))
+	     (f (cdr (assoc specifier ledger-report-format-specifiers))))
+	(if f
+	    (setq expanded-cmd (replace-match
+				(save-match-data
+				  (with-current-buffer ledger-buf
+				    (shell-quote-argument (funcall f))))
+				t t expanded-cmd))
+	  (progn
+	    (set-window-configuration ledger-original-window-cfg)
+	    (error "Invalid ledger report format specifier '%s'" specifier)))))
+    expanded-cmd))
+
+(defun ledger-report-cmd (report-name edit)
+  "Get the command line to run the report."
+  (let ((report-cmd (car (cdr (assoc report-name ledger-reports)))))
+    ;; logic for substitution goes here
+    (when (or (null report-cmd) edit)
+      (setq report-cmd (ledger-report-read-command report-cmd)))
+    (setq report-cmd (ledger-report-expand-format-specifiers report-cmd))
+    (set (make-local-variable 'ledger-report-cmd) report-cmd)
+    (or (string-empty-p report-name)
+	(ledger-report-name-exists report-name)
+	(ledger-reports-add report-name report-cmd)
+	(ledger-reports-custom-save))
+    report-cmd))
+
+(defun ledger-do-report (cmd)
+  "Run a report command line."
+  (goto-char (point-min))
+  (insert (format "Report: %s\n" ledger-report-name)
+	  (format "Command: %s\n" cmd)
+	  (make-string (- (window-width) 1) ?=)
+	  "\n")
+  (shell-command cmd t nil))
+
+(defun ledger-report-goto ()
+  "Goto the ledger report buffer."
+  (interactive)
+  (let ((rbuf (get-buffer ledger-report-buffer-name)))
+    (if (not rbuf)
+	(error "There is no ledger report buffer"))
+    (pop-to-buffer rbuf)
+    (shrink-window-if-larger-than-buffer)))
+
+(defun ledger-report-redo ()
+  "Redo the report in the current ledger report buffer."
+  (interactive)
+  (ledger-report-goto)
+  (setq buffer-read-only nil)
+  (erase-buffer)
+  (ledger-do-report ledger-report-cmd)
+  (setq buffer-read-only nil))
+
+(defun ledger-report-quit ()
+  "Quit the ledger report buffer by burying it."
+  (interactive)
+  (ledger-report-goto)
+  (set-window-configuration ledger-original-window-cfg)
+  (bury-buffer (get-buffer ledger-report-buffer-name)))
+
+(defun ledger-report-kill ()
+  "Kill the ledger report buffer."
+  (interactive)
+  (ledger-report-quit)
+  (kill-buffer (get-buffer ledger-report-buffer-name)))
+
+(defun ledger-report-edit ()
+  "Edit the defined ledger reports."
+  (interactive)
+  (customize-variable 'ledger-reports))
+
+(defun ledger-report-read-new-name ()
+  "Read the name for a new report from the minibuffer."
+  (let ((name ""))
+    (while (string-empty-p name)
+      (setq name (read-from-minibuffer "Report name: " nil nil nil
+				       'ledger-report-name-prompt-history)))
+    name))
+
+(defun ledger-report-save ()
+  "Save the current report command line as a named report."
+  (interactive)
+  (ledger-report-goto)
+  (let (existing-name)
+    (when (string-empty-p ledger-report-name)
+      (setq ledger-report-name (ledger-report-read-new-name)))
+
+    (while (setq existing-name (ledger-report-name-exists ledger-report-name))
+      (cond ((y-or-n-p (format "Overwrite existing report named '%s' "
+			       ledger-report-name))
+	     (when (string-equal
+		    ledger-report-cmd
+		    (car (cdr (assq existing-name ledger-reports))))
+	       (error "Current command is identical to existing saved one"))
+	     (setq ledger-reports
+		   (assq-delete-all existing-name ledger-reports)))
+	    (t
+	     (setq ledger-report-name (ledger-report-read-new-name)))))
+
+    (ledger-reports-add ledger-report-name ledger-report-cmd)
+    (ledger-reports-custom-save)))
+
+(defconst ledger-line-config
+  '((entry
+     (("^\\(\\([0-9][0-9][0-9][0-9]/\\)?[01]?[0-9]/[0123]?[0-9]\\)[ \t]+\\(\\([!*]\\)[ \t]\\)?[ \t]*\\((\\(.*\\))\\)?[ \t]*\\(.*?\\)[ \t]*;\\(.*\\)[ \t]*$"
+       (date nil status nil nil code payee comment))
+      ("^\\(\\([0-9][0-9][0-9][0-9]/\\)?[01]?[0-9]/[0123]?[0-9]\\)[ \t]+\\(\\([!*]\\)[ \t]\\)?[ \t]*\\((\\(.*\\))\\)?[ \t]*\\(.*\\)[ \t]*$"
+       (date nil status nil nil code payee))))
+    (acct-transaction
+     (("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\([$]\\)\\(-?[0-9]*\\(\\.[0-9]*\\)?\\)[ \t]*;[ \t]*\\(.*?\\)[ \t]*$"
+       (indent account commodity amount nil comment))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\([$]\\)\\(-?[0-9]*\\(\\.[0-9]*\\)?\\)[ \t]*$"
+       (indent account commodity amount nil))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\(-?[0-9]+\\(\\.[0-9]*\\)?\\)[ \t]+\\(.*?\\)[ \t]*;[ \t]*\\(.*?\\)[ \t]*$"
+       (indent account amount nil commodity comment))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\(-?[0-9]+\\(\\.[0-9]*\\)?\\)[ \t]+\\(.*?\\)[ \t]*$"
+       (indent account amount nil commodity))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\(-?\\(\\.[0-9]*\\)\\)[ \t]+\\(.*?\\)[ \t]*;[ \t]*\\(.*?\\)[ \t]*$"
+       (indent account amount nil commodity comment))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]+\\(-?\\(\\.[0-9]*\\)\\)[ \t]+\\(.*?\\)[ \t]*$"
+       (indent account amount nil commodity))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]*;[ \t]*\\(.*?\\)[ \t]*$"
+       (indent account comment))
+      ("\\(^[ \t]+\\)\\(.*?\\)[ \t]*$"
+       (indent account))))))
+
+(defun ledger-extract-context-info (line-type pos)
+  "Get context info for current line.
+
+Assumes point is at beginning of line, and the pos argument specifies
+where the \"users\" point was."
+  (let ((linfo (assoc line-type ledger-line-config))
+	found field fields)
+    (dolist (re-info (nth 1 linfo))
+      (let ((re (nth 0 re-info))
+	    (names (nth 1 re-info)))
+	(unless found
+	  (when (looking-at re)
+	    (setq found t)
+	    (dotimes (i (length names))
+	      (when (nth i names)
+		(setq fields (append fields
+				     (list
+				      (list (nth i names)
+					    (match-string-no-properties (1+ i))
+					    (match-beginning (1+ i))))))))
+	    (dolist (f fields)
+	      (and (nth 1 f)
+		   (>= pos (nth 2 f))
+		   (setq field (nth 0 f))))))))
+    (list line-type field fields)))
+
+(defun ledger-context-at-point ()
+  "Return a list describing the context around point.
+
+The contents of the list are the line type, the name of the field
+point containing point, and for selected line types, the content of
+the fields in the line in a association list."
+  (let ((pos (point)))
+    (save-excursion
+      (beginning-of-line)
+      (let ((first-char (char-after)))
+	(cond ((equal (point) (line-end-position))
+	       '(empty-line nil nil))
+	      ((memq first-char '(?\ ?\t))
+	       (ledger-extract-context-info 'acct-transaction pos))
+	      ((memq first-char '(?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
+	       (ledger-extract-context-info 'entry pos))
+	      ((equal first-char ?\=)
+	       '(automated-entry nil nil))
+	      ((equal first-char ?\~)
+	       '(period-entry nil nil))
+	      ((equal first-char ?\!)
+	       '(command-directive))
+	      ((equal first-char ?\;)
+	       '(comment nil nil))
+	      ((equal first-char ?Y)
+	       '(default-year nil nil))
+	      ((equal first-char ?P)
+	       '(commodity-price nil nil))
+	      ((equal first-char ?N)
+	       '(price-ignored-commodity nil nil))
+	      ((equal first-char ?D)
+	       '(default-commodity nil nil))
+	      ((equal first-char ?C)
+	       '(commodity-conversion nil nil))
+	      ((equal first-char ?i)
+	       '(timeclock-i nil nil))
+	      ((equal first-char ?o)
+	       '(timeclock-o nil nil))
+	      ((equal first-char ?b)
+	       '(timeclock-b nil nil))
+	      ((equal first-char ?h)
+	       '(timeclock-h  nil nil))
+	      (t
+	       '(unknown nil nil)))))))
+
+(defun ledger-context-other-line (offset)
+  "Return a list describing context of line offset for existing position.
+
+Offset can be positive or negative.  If run out of buffer before reaching
+specified line, returns nil."
+  (save-excursion
+    (let ((left (forward-line offset)))
+      (if (not (equal left 0))
+	  nil
+	(ledger-context-at-point)))))
+
+(defun ledger-context-line-type (context-info)
+  (nth 0 context-info))
+
+(defun ledger-context-current-field (context-info)
+  (nth 1 context-info))
+
+(defun ledger-context-field-info (context-info field-name)
+  (assoc field-name (nth 2 context-info)))
+
+(defun ledger-context-field-present-p (context-info field-name)
+  (not (null (ledger-context-field-info context-info field-name))))
+
+(defun ledger-context-field-value (context-info field-name)
+  (nth 1 (ledger-context-field-info context-info field-name)))
+
+(defun ledger-context-field-position (context-info field-name)
+  (nth 2 (ledger-context-field-info context-info field-name)))
+
+(defun ledger-context-field-end-position (context-info field-name)
+  (+ (ledger-context-field-position context-info field-name)
+     (length (ledger-context-field-value context-info field-name))))
+
+(defun ledger-context-goto-field-start (context-info field-name)
+  (goto-char (ledger-context-field-position context-info field-name)))
+
+(defun ledger-context-goto-field-end (context-info field-name)
+  (goto-char (ledger-context-field-end-position context-info field-name)))
+
+(defun ledger-entry-payee ()
+  "Returns the payee of the entry containing point or nil."
+  (let ((i 0))
+    (while (eq (ledger-context-line-type (ledger-context-other-line i)) 'acct-transaction)
+      (setq i (- i 1)))
+    (let ((context-info (ledger-context-other-line i)))
+      (if (eq (ledger-context-line-type context-info) 'entry)
+	  (ledger-context-field-value context-info 'payee)
+	nil))))
diff --git a/lisp/ldg-state.el b/lisp/ldg-state.el
new file mode 100644
index 00000000..945d72fe
--- /dev/null
+++ b/lisp/ldg-state.el
@@ -0,0 +1,189 @@
+(defcustom ledger-clear-whole-entries nil
+  "If non-nil, clear whole entries, not individual transactions."
+  :type 'boolean
+  :group 'ledger)
+
+(defun ledger-toggle-state (state &optional style)
+  (if (not (null state))
+      (if (and style (eq style 'cleared))
+	  'cleared)
+    (if (and style (eq style 'pending))
+	'pending
+      'cleared)))
+
+(defun ledger-entry-state ()
+  (save-excursion
+    (when (or (looking-at "^[0-9]")
+	      (re-search-backward "^[0-9]" nil t))
+      (skip-chars-forward "0-9./=")
+      (skip-syntax-forward " ")
+      (cond ((looking-at "!\\s-*") 'pending)
+	    ((looking-at "\\*\\s-*") 'cleared)
+	    (t nil)))))
+
+(defun ledger-transaction-state ()
+  (save-excursion
+    (goto-char (line-beginning-position))
+    (skip-syntax-forward " ")
+    (cond ((looking-at "!\\s-*") 'pending)
+	  ((looking-at "\\*\\s-*") 'cleared)
+	  (t (ledger-entry-state)))))
+
+(defun ledger-toggle-current-transaction (&optional style)
+  "Toggle the cleared status of the transaction under point.
+Optional argument STYLE may be `pending' or `cleared', depending
+on which type of status the caller wishes to indicate (default is
+`cleared').
+This function is rather complicated because it must preserve both
+the overall formatting of the ledger entry, as well as ensuring
+that the most minimal display format is used.  This could be
+achieved more certainly by passing the entry to ledger for
+formatting, but doing so causes inline math expressions to be
+dropped."
+  (interactive)
+  (let ((bounds (ledger-current-entry-bounds))
+	clear cleared)
+    ;; Uncompact the entry, to make it easier to toggle the
+    ;; transaction
+    (save-excursion
+      (goto-char (car bounds))
+      (skip-chars-forward "0-9./= \t")
+      (setq cleared (and (member (char-after) '(?\* ?\!))
+			 (char-after)))
+      (when cleared
+	(let ((here (point)))
+	  (skip-chars-forward "*! ")
+	  (let ((width (- (point) here)))
+	    (when (> width 0)
+	      (delete-region here (point))
+	      (if (search-forward "  " (line-end-position) t)
+		  (insert (make-string width ? ))))))
+	(forward-line)
+	(while (looking-at "[ \t]")
+	  (skip-chars-forward " \t")
+	  (insert cleared " ")
+	  (if (search-forward "  " (line-end-position) t)
+	      (delete-char 2))
+	  (forward-line))))
+    ;; Toggle the individual transaction
+    (save-excursion
+      (goto-char (line-beginning-position))
+      (when (looking-at "[ \t]")
+	(skip-chars-forward " \t")
+	(let ((here (point))
+	      (cleared (member (char-after) '(?\* ?\!))))
+	  (skip-chars-forward "*! ")
+	  (let ((width (- (point) here)))
+	    (when (> width 0)
+	      (delete-region here (point))
+	      (save-excursion
+		(if (search-forward "  " (line-end-position) t)
+		    (insert (make-string width ? ))))))
+	  (let (inserted)
+	    (if cleared
+		(if (and style (eq style 'cleared))
+		    (progn
+		      (insert "* ")
+		      (setq inserted t)))
+	      (if (and style (eq style 'pending))
+		  (progn
+		    (insert "! ")
+		    (setq inserted t))
+		(progn
+		  (insert "* ")
+		  (setq inserted t))))
+	    (if (and inserted
+		     (re-search-forward "\\(\t\\| [ \t]\\)"
+					(line-end-position) t))
+		(cond
+		 ((looking-at "\t")
+		  (delete-char 1))
+		 ((looking-at " [ \t]")
+		  (delete-char 2))
+		 ((looking-at " ")
+		  (delete-char 1))))
+	    (setq clear inserted)))))
+    ;; Clean up the entry so that it displays minimally
+    (save-excursion
+      (goto-char (car bounds))
+      (forward-line)
+      (let ((first t)
+	    (state ? )
+	    (hetero nil))
+	(while (and (not hetero) (looking-at "[ \t]"))
+	  (skip-chars-forward " \t")
+	  (let ((cleared (if (member (char-after) '(?\* ?\!))
+			     (char-after)
+			   ? )))
+	    (if first
+		(setq state cleared
+		      first nil)
+	      (if (/= state cleared)
+		  (setq hetero t))))
+	  (forward-line))
+	(when (and (not hetero) (/= state ? ))
+	  (goto-char (car bounds))
+	  (forward-line)
+	  (while (looking-at "[ \t]")
+	    (skip-chars-forward " \t")
+	    (let ((here (point)))
+	      (skip-chars-forward "*! ")
+	      (let ((width (- (point) here)))
+		(when (> width 0)
+		  (delete-region here (point))
+		  (if (re-search-forward "\\(\t\\| [ \t]\\)"
+					 (line-end-position) t)
+		      (insert (make-string width ? ))))))
+	    (forward-line))
+	  (goto-char (car bounds))
+	  (skip-chars-forward "0-9./= \t")
+	  (insert state " ")
+	  (if (re-search-forward "\\(\t\\| [ \t]\\)"
+				 (line-end-position) t)
+	      (cond
+	       ((looking-at "\t")
+		(delete-char 1))
+	       ((looking-at " [ \t]")
+		(delete-char 2))
+	       ((looking-at " ")
+		(delete-char 1)))))))
+    clear))
+
+(defun ledger-toggle-current (&optional style)
+  (interactive)
+  (if (or ledger-clear-whole-entries
+	  (eq 'entry (ledger-thing-at-point)))
+      (progn
+	(save-excursion
+	  (forward-line)
+	  (goto-char (line-beginning-position))
+	  (while (and (not (eolp))
+		      (save-excursion
+			(not (eq 'entry (ledger-thing-at-point)))))
+	    (if (looking-at "\\s-+[*!]")
+		(ledger-toggle-current-transaction nil))
+	    (forward-line)
+	    (goto-char (line-beginning-position))))
+	(ledger-toggle-current-entry style))
+    (ledger-toggle-current-transaction style)))
+
+(defun ledger-toggle-current-entry (&optional style)
+  (interactive)
+  (let (clear)
+    (save-excursion
+      (when (or (looking-at "^[0-9]")
+		(re-search-backward "^[0-9]" nil t))
+	(skip-chars-forward "0-9./=")
+	(delete-horizontal-space)
+	(if (member (char-after) '(?\* ?\!))
+	    (progn
+	      (delete-char 1)
+	      (if (and style (eq style 'cleared))
+		  (insert " *")))
+	  (if (and style (eq style 'pending))
+	      (insert " ! ")
+	    (insert " * "))
+	  (setq clear t))))
+    clear))
+
+(provide 'ldg-state)
diff --git a/lisp/ldg-xact.el b/lisp/ldg-xact.el
new file mode 100644
index 00000000..5945632a
--- /dev/null
+++ b/lisp/ldg-xact.el
@@ -0,0 +1,20 @@
+;; A sample entry sorting function, which works if entry dates are of
+;; the form YYYY/mm/dd.
+
+(defun ledger-sort ()
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (sort-subr
+     nil
+     (function
+      (lambda ()
+	(if (re-search-forward
+	     (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+		     "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)
+	    (goto-char (match-beginning 0))
+	  (goto-char (point-max)))))
+     (function
+      (lambda ()
+	(forward-paragraph))))))
+
-- 
cgit v1.2.3


From 056994497ea743a1e2d4782312eab65c31cb73b8 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Mon, 12 Apr 2010 23:10:07 -0400
Subject: Some more refactoring of the new Lisp code

---
 lisp/ldg-exec.el      | 45 +++++++++++++++++++-------------------
 lisp/ldg-reconcile.el | 41 +----------------------------------
 lisp/ldg-register.el  | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 62 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-exec.el b/lisp/ldg-exec.el
index d740fccc..3881f8e9 100644
--- a/lisp/ldg-exec.el
+++ b/lisp/ldg-exec.el
@@ -1,4 +1,4 @@
-(defgroup ledger-binary nil
+(defgroup ledger-exec nil
   "Interface to the Ledger command-line accounting program."
   :group 'ledger)
 
@@ -7,27 +7,28 @@
   :type 'file
   :group 'ledger)
 
-(defvar ledger-delete-after nil)
+(defun ledger-exec-ledger (input-buffer &optional output-buffer &rest args)
+  "Run Ledger."
+  (if (null ledger-binary-path)
+      (error "The variable `ledger-binary-path' has not been set"))
+  (let ((buf (or input-buffer (current-buffer)))
+	(outbuf (or output-buffer
+		    (generate-new-buffer " *ledger-tmp*"))))
+    (with-current-buffer buf
+      (let ((coding-system-for-write 'utf-8)
+	    (coding-system-for-read 'utf-8))
+	(apply #'call-process-region
+	       (append (list (point-min) (point-max)
+			     ledger-binary-path nil outbuf nil "-f" "-")
+		       args)))
+      outbuf)))
 
-(defun ledger-run-ledger (buffer &rest args)
-  "run ledger with supplied arguments"
-  ;; Let's try again, just in case they moved it while we were sleeping.
-  (cond
-   ((null ledger-binary-path)
-    (error "The variable `ledger-binary-path' has not been set"))
-   (t
-    (let ((buf (current-buffer)))
-      (with-current-buffer buffer
-	(let ((coding-system-for-write 'utf-8)
-	      (coding-system-for-read 'utf-8))
-	  (apply #'call-process-region
-		 (append (list (point-min) (point-max)
-			       ledger-binary-path ledger-delete-after
-			       buf nil "-f" "-")
-			 args))))))))
-
-(defun ledger-run-ledger-and-delete (buffer &rest args)
-  (let ((ledger-delete-after t))
-    (apply #'ledger-run-ledger buffer args)))
+(defun ledger-exec-read (&optional input-buffer &rest args)
+  (with-current-buffer
+      (apply #'ledger-exec-ledger input-buffer nil "emacs" args)
+    (goto-char (point-min))
+    (prog1
+	(read (current-buffer))
+      (kill-buffer (current-buffer)))))
 
 (provide 'ldg-exec)
diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el
index e19e0705..3be882f4 100644
--- a/lisp/ldg-reconcile.el
+++ b/lisp/ldg-reconcile.el
@@ -105,46 +105,7 @@
   (ledger-reconcile-save))
 
 (defun ledger-do-reconcile ()
-  (let* ((buf ledger-buf)
-	 (account ledger-acct)
-	 (items
-	  (with-temp-buffer
-	    (let ((exit-code
-		   (ledger-run-ledger buf "--uncleared" "emacs" account)))
-	      (when (= 0 exit-code)
-		(goto-char (point-min))
-		(unless (eobp)
-		  (unless (looking-at "(")
-		    (error (buffer-string)))
-		  (read (current-buffer))))))))
-    (dolist (item items)
-      (let ((index 1))
-	(dolist (xact (nthcdr 5 item))
-	  (let ((beg (point))
-		(where
-		 (with-current-buffer buf
-		   (cons
-		    (nth 0 item)
-		    (if ledger-clear-whole-entries
-			(save-excursion
-			  (goto-line (nth 1 item))
-			  (point-marker))
-		      (save-excursion
-			(goto-line (nth 0 xact))
-			(point-marker)))))))
-	    (insert (format "%s %-30s %-25s %15s\n"
-			    (format-time-string "%m/%d" (nth 2 item))
-			    (nth 4 item) (nth 1 xact) (nth 2 xact)))
-	    (if (nth 3 xact)
-		(set-text-properties beg (1- (point))
-				     (list 'face 'bold
-					   'where where))
-	      (set-text-properties beg (1- (point))
-				   (list 'where where))))
-	  (setq index (1+ index)))))
-    (goto-char (point-min))
-    (set-buffer-modified-p nil)
-    (toggle-read-only t)))
+  )
 
 (defun ledger-reconcile (account)
   (interactive "sAccount to reconcile: ")
diff --git a/lisp/ldg-register.el b/lisp/ldg-register.el
index 8f0c8195..93611345 100644
--- a/lisp/ldg-register.el
+++ b/lisp/ldg-register.el
@@ -1,7 +1,67 @@
 (require 'ldg-post)
+(require 'ldg-state)
 
 (defgroup ledger-register nil
   ""
   :group 'ledger)
 
+(defcustom ledger-register-date-format "%m/%d/%y"
+  "*The date format used for ledger register reports."
+  :type 'string
+  :group 'ledger-register)
+
+(defcustom ledger-register-line-format "%s %-30.30s %-25.25s %15s\n"
+  "*The date format used for ledger register reports."
+  :type 'string
+  :group 'ledger-register)
+
+(defface ledger-register-pending-face
+  '((((background light)) (:weight bold))
+    (((background dark)) (:weight bold)))
+  "Face used to highlight pending entries in a register report."
+  :group 'ledger-register)
+
+(defun ledger-register-render (data-buffer posts)
+  (dolist (post posts)
+    (let ((index 1))
+      (dolist (xact (nthcdr 5 post))
+	(let ((beg (point))
+	      (where
+	       (with-current-buffer data-buffer
+		 (cons
+		  (nth 0 post)
+		  (if ledger-clear-whole-entries
+		      (save-excursion
+			(goto-line (nth 1 post))
+			(point-marker))
+		    (save-excursion
+		      (goto-line (nth 0 xact))
+		      (point-marker)))))))
+	  (insert (format ledger-register-line-format
+			  (format-time-string ledger-register-date-format
+					      (nth 2 post))
+			  (nth 4 post) (nth 1 xact) (nth 2 xact)))
+	  (if (nth 3 xact)
+	      (set-text-properties beg (1- (point))
+				   (list 'face 'ledger-register-pending-face
+					 'where where))
+	    (set-text-properties beg (1- (point))
+				 (list 'where where))))
+	(setq index (1+ index)))))
+  (goto-char (point-min))
+  )
+
+(defun ledger-register-generate (&optional data-buffer &rest args)
+  (let ((buf (or data-buffer (current-buffer))))
+    (with-current-buffer (get-buffer-create "*ledger-register*")
+      (let ((pos (point))
+	    (inhibit-read-only t))
+	(erase-buffer)
+	(ledger-register-render
+	 buf (apply #'ledger-exec-read buf args))
+	(goto-char pos))
+      (set-buffer-modified-p nil)
+      (toggle-read-only t)
+      (display-buffer (current-buffer) t))))
+
 (provide 'ldg-register)
-- 
cgit v1.2.3


From 7f5c1c81a1918dd3f7293a66b988599a0125b1f9 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Sun, 2 May 2010 23:50:17 -0400
Subject: Added some missing autoloads for the new ledger-mode

---
 lisp/ldg-mode.el     |   2 +
 lisp/ldg-new.el      |   4 ++
 lisp/ldg-post.el     |   9 ++-
 lisp/ldg-regex.el    | 152 +++++++++++++++++++++++++--------------------------
 lisp/ldg-register.el |   3 +-
 5 files changed, 90 insertions(+), 80 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
index 625d9f49..c6f15eed 100644
--- a/lisp/ldg-mode.el
+++ b/lisp/ldg-mode.el
@@ -22,6 +22,8 @@
 ;;;###autoload
 (define-derived-mode ledger-mode text-mode "Ledger"
   "A mode for editing ledger data files."
+  (ledger-post-setup)
+
   (set (make-local-variable 'comment-start) " ; ")
   (set (make-local-variable 'comment-end) "")
   (set (make-local-variable 'indent-tabs-mode) nil)
diff --git a/lisp/ldg-new.el b/lisp/ldg-new.el
index fce25984..a515d94f 100644
--- a/lisp/ldg-new.el
+++ b/lisp/ldg-new.el
@@ -34,6 +34,10 @@
 
 (require 'ldg-post)
 
+(autoload #'ledger-mode "ldg-mode" nil t)
+
+(autoload #'ledger-fully-complete-entry "ldg-complete" nil t)
+
 (autoload #'ledger-texi-update-test "ldg-texi" nil t)
 (autoload #'ledger-texi-update-examples "ldg-texi" nil t)
 
diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index 2d7a0e05..492f9467 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -83,6 +83,13 @@ to choose from."
 		(delete-char 1)))))))
     (goto-char pos)))
 
+(defun ledger-next-amount (&optional end)
+  (when (re-search-forward "\\(  \\|\t\\| \t\\)[ \t]*-?\\([A-Z$]+ *\\)?\\(-?[0-9,]+?\\)\\(.[0-9]+\\)?\\( *[A-Z$]+\\)?\\([ \t]*@@?[^\n;]+?\\)?\\([ \t]+;.+?\\)?$" (marker-position end) t)
+    (goto-char (match-beginning 0))
+    (skip-syntax-forward " ")
+    (- (or (match-end 4)
+	   (match-end 3)) (point))))
+
 (defun ledger-align-amounts (&optional column)
   "Align amounts in the current region.
 This is done so that the last digit falls in COLUMN, which defaults to 52."
@@ -164,6 +171,4 @@ This is done so that the last digit falls in COLUMN, which defaults to 52."
       (add-hook 'after-change-functions 'ledger-post-maybe-align t t))
   (add-hook 'after-save-hook #'(lambda () (setq ledger-post-current-list nil))))
 
-(add-hook 'ledger-mode-hook 'ledger-post-setup)
-
 (provide 'ldg-post)
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 15226ef1..93ef6b09 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -96,64 +96,64 @@
 
     (cons 'progn defs)))
 
-(put 'ledger-define-regexp 'lisp-indent-function 2)
+(put 'ledger-define-regexp 'lisp-indent-function 1)
 
 (ledger-define-regexp date
-    (let ((sep '(or ?- (any ?. ?/))))	; can't do (any ?- ?. ?/) due to bug
-      (rx (group
-	   (and (? (= 4 num)
-		   (eval sep))
-		(and num (? num))
-		(eval sep)
-		(and num (? num))))))
+  (let ((sep '(or ?- (any ?. ?/))))	; can't do (any ?- ?. ?/) due to bug
+    (rx (group
+	 (and (? (= 4 num)
+		 (eval sep))
+	      (and num (? num))
+	      (eval sep)
+	      (and num (? num))))))
   "Match a single date, in its 'written' form.")
 
 (ledger-define-regexp full-date
-    (macroexpand
-     `(rx (and (regexp ,ledger-date-regexp)
-	       (? (and ?= (regexp ,ledger-date-regexp))))))
+  (macroexpand
+   `(rx (and (regexp ,ledger-date-regexp)
+	     (? (and ?= (regexp ,ledger-date-regexp))))))
   "Match a compound date, of the form ACTUAL=EFFECTIVE"
   (actual date)
   (effective date))
 
 (ledger-define-regexp state
-    (rx (group (any ?! ?*)))
+  (rx (group (any ?! ?*)))
   "Match a transaction or posting's \"state\" character.")
 
 (ledger-define-regexp code
-    (rx (and ?\( (group (+? (not (any ?\))))) ?\)))
+  (rx (and ?\( (group (+? (not (any ?\))))) ?\)))
   "Match the transaction code.")
 
 (ledger-define-regexp long-space
-    (rx (and (*? blank)
-	     (or (and ?  (or ?  ?\t)) ?\t)))
+  (rx (and (*? blank)
+	   (or (and ?  (or ?  ?\t)) ?\t)))
   "Match a \"long space\".")
 
 (ledger-define-regexp note
-    (rx (group (+ nonl)))
+  (rx (group (+ nonl)))
   "")
 
 (ledger-define-regexp end-note
-    (macroexpand
-     `(rx (and (regexp ,ledger-long-space-regexp) ?\;
-	       (regexp ,ledger-note-regexp))))
+  (macroexpand
+   `(rx (and (regexp ,ledger-long-space-regexp) ?\;
+	     (regexp ,ledger-note-regexp))))
   "")
 
 (ledger-define-regexp full-note
-    (macroexpand
-     `(rx (and line-start (+ blank)
-	       ?\; (regexp ,ledger-note-regexp))))
+  (macroexpand
+   `(rx (and line-start (+ blank)
+	     ?\; (regexp ,ledger-note-regexp))))
   "")
 
 (ledger-define-regexp xact-line
-    (macroexpand
-     `(rx (and line-start
-	       (regexp ,ledger-full-date-regexp)
-	       (? (and (+ blank) (regexp ,ledger-state-regexp)))
-	       (? (and (+ blank) (regexp ,ledger-code-regexp)))
-	       (+ blank) (+? nonl)
-	       (? (regexp ,ledger-end-note-regexp))
-	       line-end)))
+  (macroexpand
+   `(rx (and line-start
+	     (regexp ,ledger-full-date-regexp)
+	     (? (and (+ blank) (regexp ,ledger-state-regexp)))
+	     (? (and (+ blank) (regexp ,ledger-code-regexp)))
+	     (+ blank) (+? nonl)
+	     (? (regexp ,ledger-end-note-regexp))
+	     line-end)))
   "Match a transaction's first line (and optional notes)."
   (actual-date full-date actual)
   (effective-date full-date effective)
@@ -162,84 +162,84 @@
   (note end-note))
 
 (ledger-define-regexp account
-    (rx (group (and (not (any blank ?\[ ?\( ?: ?\;)) (*? nonl))))
+  (rx (group (and (not (any blank ?\[ ?\( ?: ?\;)) (*? nonl))))
   "")
 
 (ledger-define-regexp account-kind
-    (rx (group (? (any ?\[ ?\())))
+  (rx (group (? (any ?\[ ?\())))
   "")
 
 (ledger-define-regexp full-account
-    (macroexpand
-     `(rx (and (regexp ,ledger-account-kind-regexp)
-	       (regexp ,ledger-account-regexp)
-	       (? (any ?\] ?\))))))
+  (macroexpand
+   `(rx (and (regexp ,ledger-account-kind-regexp)
+	     (regexp ,ledger-account-regexp)
+	     (? (any ?\] ?\))))))
   ""
   (kind account-kind)
   (name account))
 
 (ledger-define-regexp commodity
-    (rx (group
-	 (or (and ?\" (+ (not (any ?\"))) ?\")
-	     (not (any blank ?\n
-		       digit
-		       ?- ?\[ ?\]
-		       ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?=
-		       ?\< ?\> ?\{ ?\} ?\( ?\) ?@)))))
+  (rx (group
+       (or (and ?\" (+ (not (any ?\"))) ?\")
+	   (not (any blank ?\n
+		     digit
+		     ?- ?\[ ?\]
+		     ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?=
+		     ?\< ?\> ?\{ ?\} ?\( ?\) ?@)))))
   "")
 
 (ledger-define-regexp amount
-    (rx (group
-	 (and (? ?-)
-	      (and (+ digit)
-		   (*? (and (any ?. ?,) (+ digit))))
-	      (? (and (any ?. ?,) (+ digit))))))
+  (rx (group
+       (and (? ?-)
+	    (and (+ digit)
+		 (*? (and (any ?. ?,) (+ digit))))
+	    (? (and (any ?. ?,) (+ digit))))))
   "")
 
 (ledger-define-regexp commoditized-amount
-    (macroexpand
-     `(rx (group
-	   (or (and (regexp ,ledger-commodity-regexp)
-		    (*? blank)
-		    (regexp ,ledger-amount-regexp))
-	       (and (regexp ,ledger-amount-regexp)
-		    (*? blank)
-		    (regexp ,ledger-commodity-regexp))))))
+  (macroexpand
+   `(rx (group
+	 (or (and (regexp ,ledger-commodity-regexp)
+		  (*? blank)
+		  (regexp ,ledger-amount-regexp))
+	     (and (regexp ,ledger-amount-regexp)
+		  (*? blank)
+		  (regexp ,ledger-commodity-regexp))))))
   "")
 
 (ledger-define-regexp commodity-annotations
-    (macroexpand
-     `(rx (* (+ blank)
-	     (or (and ?\{ (regexp ,ledger-commoditized-amount-regexp) ?\})
-		 (and ?\[ (regexp ,ledger-date-regexp) ?\])
-		 (and ?\( (not (any ?\))) ?\))))))
+  (macroexpand
+   `(rx (* (+ blank)
+	   (or (and ?\{ (regexp ,ledger-commoditized-amount-regexp) ?\})
+	       (and ?\[ (regexp ,ledger-date-regexp) ?\])
+	       (and ?\( (not (any ?\))) ?\))))))
   "")
 
 (ledger-define-regexp cost
-    (macroexpand
-     `(rx (and (or "@" "@@") (+ blank)
-	       (regexp ,ledger-commoditized-amount-regexp))))
+  (macroexpand
+   `(rx (and (or "@" "@@") (+ blank)
+	     (regexp ,ledger-commoditized-amount-regexp))))
   "")
 
 (ledger-define-regexp balance-assertion
-    (macroexpand
-     `(rx (and ?= (+ blank)
-	       (regexp ,ledger-commoditized-amount-regexp))))
+  (macroexpand
+   `(rx (and ?= (+ blank)
+	     (regexp ,ledger-commoditized-amount-regexp))))
   "")
 
 (ledger-define-regexp full-amount
-    (macroexpand `(rx (group (+? (not (any ?\;))))))
+  (macroexpand `(rx (group (+? (not (any ?\;))))))
   "")
 
 (ledger-define-regexp post-line
-    (macroexpand
-     `(rx (and line-start (+ blank)
-	       (? (and (regexp ,ledger-state-regexp) (* blank)))
-	       (regexp ,ledger-full-account-regexp)
-	       (? (and (regexp ,ledger-long-space-regexp)
-		       (regexp ,ledger-full-amount-regexp)))
-	       (? (regexp ,ledger-end-note-regexp))
-	       line-end)))
+  (macroexpand
+   `(rx (and line-start (+ blank)
+	     (? (and (regexp ,ledger-state-regexp) (* blank)))
+	     (regexp ,ledger-full-account-regexp)
+	     (? (and (regexp ,ledger-long-space-regexp)
+		     (regexp ,ledger-full-amount-regexp)))
+	     (? (regexp ,ledger-end-note-regexp))
+	     line-end)))
   ""
   state
   (account-kind full-account kind)
diff --git a/lisp/ldg-register.el b/lisp/ldg-register.el
index 93611345..02e50de9 100644
--- a/lisp/ldg-register.el
+++ b/lisp/ldg-register.el
@@ -57,8 +57,7 @@
       (let ((pos (point))
 	    (inhibit-read-only t))
 	(erase-buffer)
-	(ledger-register-render
-	 buf (apply #'ledger-exec-read buf args))
+	(ledger-register-render buf (apply #'ledger-exec-read buf args))
 	(goto-char pos))
       (set-buffer-modified-p nil)
       (toggle-read-only t)
-- 
cgit v1.2.3


From d728e1364a4499d9965c513c92468d2a89882433 Mon Sep 17 00:00:00 2001
From: John Wiegley <johnw@newartisans.com>
Date: Fri, 7 May 2010 22:57:05 -0400
Subject: Make sure ldg-new.el loads correctly

---
 lisp/ldg-complete.el | 1 +
 lisp/ldg-mode.el     | 1 +
 lisp/ldg-new.el      | 9 ++++++---
 3 files changed, 8 insertions(+), 3 deletions(-)

(limited to 'lisp')

diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el
index cc2ac152..33a734b3 100644
--- a/lisp/ldg-complete.el
+++ b/lisp/ldg-complete.el
@@ -153,3 +153,4 @@
       (if (re-search-backward "\\(\t\\| [ \t]\\)" nil t)
 	  (goto-char (match-end 0))))))
 
+(provide 'ldg-complete)
diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
index c6f15eed..973b891c 100644
--- a/lisp/ldg-mode.el
+++ b/lisp/ldg-mode.el
@@ -114,3 +114,4 @@ Return the difference in the format of a time value."
   (let ((bounds (ledger-current-entry-bounds)))
     (delete-region (car bounds) (cdr bounds))))
 
+(provide 'ldg-mode)
diff --git a/lisp/ldg-new.el b/lisp/ldg-new.el
index a515d94f..84863c95 100644
--- a/lisp/ldg-new.el
+++ b/lisp/ldg-new.el
@@ -33,10 +33,13 @@
 ;;; Commentary:
 
 (require 'ldg-post)
+(require 'ldg-mode)
+(require 'ldg-complete)
+(require 'ldg-state)
 
-(autoload #'ledger-mode "ldg-mode" nil t)
-
-(autoload #'ledger-fully-complete-entry "ldg-complete" nil t)
+;(autoload #'ledger-mode "ldg-mode" nil t)
+;(autoload #'ledger-fully-complete-entry "ldg-complete" nil t)
+;(autoload #'ledger-toggle-current "ldg-state" nil t)
 
 (autoload #'ledger-texi-update-test "ldg-texi" nil t)
 (autoload #'ledger-texi-update-examples "ldg-texi" nil t)
-- 
cgit v1.2.3