diff options
138 files changed, 7102 insertions, 7102 deletions
@@ -13,7 +13,7 @@ and it will keep you updated to the very latest version. =============================================================================== - NOTE FOR MAC OS X USERS + NOTE FOR MAC OS X USERS To build and install Ledger on the Mac requires several dependencies. If you are a MacPorts user, you can install these dependencies very simply using: @@ -33,7 +33,7 @@ available for testing and more useful bug reports. =============================================================================== - IF YOU HAVE CONFIGURE OR BUILD PROBLEMS + IF YOU HAVE CONFIGURE OR BUILD PROBLEMS The first order of business if acprep update doesn't work is to find out where things went wrong. So follow these steps to produce a bug report I can track diff --git a/README.textile b/README.textile index 2a730746..2d36c20a 100644 --- a/README.textile +++ b/README.textile @@ -105,10 +105,10 @@ If you're going to be build on Ubuntu, @sudo apt-get install ...@ the following packages (current as of Ubuntu Hardy): <pre> -sudo apt-get install build-essential libtool autoconf automake \ +sudo apt-get install build-essential libtool autoconf automake \ zlib1g-dev libbz2-dev python-dev bjam cvs gettext libgmp3-dev \ - libmpfr-dev libboost1.35-dev libboost-regex1.35-dev \ - libboost-date-time1.35-dev libboost-filesystem1.35-dev \ + libmpfr-dev libboost1.35-dev libboost-regex1.35-dev \ + libboost-date-time1.35-dev libboost-filesystem1.35-dev \ libboost-python1.35-dev texinfo lcov sloccount </pre> @@ -661,7 +661,7 @@ class PrepareBuild(CommandLineApp): def phase_sloc(self, *args): self.log.info('Executing phase: sloc') - self.execute('sloccount', 'src', 'python', 'lisp', 'test') + self.execute('sloccount', 'src', 'python', 'lisp', 'test') ######################################################################### # Configure source tree using autogen # @@ -1087,30 +1087,30 @@ class PrepareBuild(CommandLineApp): def option_warn(self, option=None, opt_str=None, value=None, parser=None): self.log.debug('Saw option --warn') - self.CXXFLAGS.append('-ansi') - self.CXXFLAGS.append('-pedantic') - self.CXXFLAGS.append('-pedantic-errors') - self.CXXFLAGS.append('-Wall') - self.CXXFLAGS.append('-Winvalid-pch') - self.CXXFLAGS.append('-Wextra') - self.CXXFLAGS.append('-Wcast-align') - self.CXXFLAGS.append('-Wcast-qual') - self.CXXFLAGS.append('-Wfloat-equal') - self.CXXFLAGS.append('-Wmissing-field-initializers') - self.CXXFLAGS.append('-Wno-endif-labels') - self.CXXFLAGS.append('-Woverloaded-virtual') - self.CXXFLAGS.append('-Wsign-compare') - self.CXXFLAGS.append('-Wsign-promo') - self.CXXFLAGS.append('-Wstrict-null-sentinel') - self.CXXFLAGS.append('-Wwrite-strings') - self.CXXFLAGS.append('-Wno-old-style-cast') - self.CXXFLAGS.append('-Wno-deprecated') - self.CXXFLAGS.append('-Wno-strict-aliasing') - self.CXXFLAGS.append('-Werror') + self.CXXFLAGS.append('-ansi') + self.CXXFLAGS.append('-pedantic') + self.CXXFLAGS.append('-pedantic-errors') + self.CXXFLAGS.append('-Wall') + self.CXXFLAGS.append('-Winvalid-pch') + self.CXXFLAGS.append('-Wextra') + self.CXXFLAGS.append('-Wcast-align') + self.CXXFLAGS.append('-Wcast-qual') + self.CXXFLAGS.append('-Wfloat-equal') + self.CXXFLAGS.append('-Wmissing-field-initializers') + self.CXXFLAGS.append('-Wno-endif-labels') + self.CXXFLAGS.append('-Woverloaded-virtual') + self.CXXFLAGS.append('-Wsign-compare') + self.CXXFLAGS.append('-Wsign-promo') + self.CXXFLAGS.append('-Wstrict-null-sentinel') + self.CXXFLAGS.append('-Wwrite-strings') + self.CXXFLAGS.append('-Wno-old-style-cast') + self.CXXFLAGS.append('-Wno-deprecated') + self.CXXFLAGS.append('-Wno-strict-aliasing') + self.CXXFLAGS.append('-Werror') def option_pic(self, option=None, opt_str=None, value=None, parser=None): self.log.debug('Saw option --pic') - self.CXXFLAGS.append('-fPIC') + self.CXXFLAGS.append('-fPIC') def option_output(self, option=None, opt_str=None, value=None, parser=None): self.log.debug('Saw option --output') @@ -1,4 +1,4 @@ - Ledger NEWS + Ledger NEWS * 3.0 @@ -291,7 +291,7 @@ features, please see the manual. monthly costs report, for example, because it makes the following command possible: - ledger -M --only "a>100" reg ^Expenses:Food + ledger -M --only "a>100" reg ^Expenses:Food This shows only *months* whose amount is greater than 100. If --limit had been used, it would have been a monthly summary of @@ -303,7 +303,7 @@ features, please see the manual. This predicate does not constrain calculation, but only display. Consider the same command as above: - ledger -M --display "a>100" reg ^Expenses:Food + ledger -M --display "a>100" reg ^Expenses:Food This displays only lines whose amount is greater than 100, *yet the running total still includes amounts from all transactions*. @@ -311,7 +311,7 @@ features, please see the manual. the current month's checking register while still giving a correct ending balance: - ledger --display "d>[this month]" reg Checking + ledger --display "d>[this month]" reg Checking Note that these predicates can be combined. Here is a report that considers only food bills whose individual cost is greater than @@ -320,8 +320,8 @@ features, please see the manual. retain an accurate running total with respect to the entire ledger file: - ledger -M --limit "a>20" --only "a>200" \ - --display "year == yearof([last year])" reg ^Expenses:Food + ledger -M --limit "a>20" --only "a>200" \ + --display "year == yearof([last year])" reg ^Expenses:Food - Added new "--descend AMOUNT" and "--descend-if VALEXPR" reporting options. For any reports that display valued transactions (i.e., @@ -398,12 +398,12 @@ features, please see the manual. G gain_total U(x) abs(x) S(x) quant(x), quantity(x) - comm(x), commodity(x) - setcomm(x,y), set_commodity(x,y) + comm(x), commodity(x) + setcomm(x,y), set_commodity(x,y) A(x) mean(x), avg(x), average(x) P(x,y) val(x,y), value(x,y) - min(x,y) - max(x,y) + min(x,y) + max(x,y) - There are new "parse" and "expr" commands, whose argument is a single value expression. Ledger will simply print out the result of @@ -554,10 +554,10 @@ features, please see the manual. the following is now supported, which wasn't previously: 2004/06/21 Adjustment - Retirement 100 FUNDA - Retirement 200 FUNDB - Retirement 300 FUNDC - Equity:Adjustments + Retirement 100 FUNDA + Retirement 200 FUNDB + Retirement 300 FUNDC + Equity:Adjustments - Fixed several bugs relating to QIF parsing, budgeting and forecasting. @@ -1,7 +1,7 @@ - Welcome to Ledger + Welcome to Ledger - the command-line accounting program + the command-line accounting program Introduction ============ diff --git a/doc/grammar.y b/doc/grammar.y index 018e7391..9a5f740b 100644 --- a/doc/grammar.y +++ b/doc/grammar.y @@ -53,7 +53,7 @@ journal_item: whitespace: EOL | WHITESPACE EOL | - ';' TEXT EOL | /* these next four are all ignored */ + ';' TEXT EOL | /* these next four are all ignored */ '*' TEXT EOL | ; @@ -70,23 +70,23 @@ word_directive: "end" | "alias" STRING '=' TEXT | "def" TEXT | - TEXT WHITESPACE TEXT /* looked up in session (aka maybe Python) */ + TEXT WHITESPACE TEXT /* looked up in session (aka maybe Python) */ ; char_directive: - 'i' date time TEXT | /* a timeclock.el "check in" */ + 'i' date time TEXT | /* a timeclock.el "check in" */ 'I' date time TEXT | - 'o' date time TEXT | /* a timeclock.el "check out" */ + 'o' date time TEXT | /* a timeclock.el "check out" */ 'O' date time TEXT | 'h' TEXT EOL | 'b' TEXT EOL | - 'D' amount | /* sets display parameters for a commodity */ - 'A' TEXT | /* sets the "default balancing account" */ - 'C' commodity '=' amount | /* specifies a commodity conversion */ + 'D' amount | /* sets display parameters for a commodity */ + 'A' TEXT | /* sets the "default balancing account" */ + 'C' commodity '=' amount | /* specifies a commodity conversion */ 'P' date time commodity amount | /* a pricing history xact */ - 'N' commodity | /* commodity's price is never downloaded */ - 'Y' INT4 | /* sets the default year for date parsing */ - '-' '-' STRING TEXT | /* specify command-line options in the file */ + 'N' commodity | /* commodity's price is never downloaded */ + 'Y' INT4 | /* sets the default year for date parsing */ + '-' '-' STRING TEXT | /* specify command-line options in the file */ ; date: INT4 date_sep INT2 date_sep INT2 ; @@ -210,7 +210,7 @@ values_opt: price_opt: price | /* epsilon */ ; price: '@' amount_expr | - '@@' amount_expr /* in this case, it's the whole price */ + '@@' amount_expr /* in this case, it's the whole price */ ; account: diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el index 33a734b3..7b4b0471 100644 --- a/lisp/ldg-complete.el +++ b/lisp/ldg-complete.el @@ -8,46 +8,46 @@ (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)))))) + (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) + (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))) + (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) + 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))))) + (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) @@ -58,99 +58,99 @@ (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))))))))) + "^[ \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)) + (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))) + (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)))) + (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))))) + (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) + 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 (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)))) + (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)))))) + (goto-char (match-end 0)))))) (provide 'ldg-complete) diff --git a/lisp/ldg-exec.el b/lisp/ldg-exec.el index 3881f8e9..bf3565b4 100644 --- a/lisp/ldg-exec.el +++ b/lisp/ldg-exec.el @@ -12,15 +12,15 @@ (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*")))) + (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))) + (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-exec-read (&optional input-buffer &rest args) @@ -28,7 +28,7 @@ (apply #'ledger-exec-ledger input-buffer nil "emacs" args) (goto-char (point-min)) (prog1 - (read (current-buffer)) + (read (current-buffer)) (kill-buffer (current-buffer))))) (provide 'ldg-exec) diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el index 973b891c..3e9a9106 100644 --- a/lisp/ldg-mode.el +++ b/lisp/ldg-mode.el @@ -5,13 +5,13 @@ (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-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)) @@ -30,7 +30,7 @@ (if (boundp 'font-lock-defaults) (set (make-local-variable 'font-lock-defaults) - '(ledger-font-lock-keywords nil t))) + '(ledger-font-lock-keywords nil t))) (set (make-local-variable 'pcomplete-parse-arguments-function) 'ledger-parse-arguments) @@ -56,58 +56,58 @@ "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))))) + (< (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))))) + (- (+ (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))))))) + (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) + (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))) + (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))) + (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)) + (re-search-backward "^[0-9]" nil t)) (let ((beg (point))) - (while (not (eolp)) - (forward-line)) - (cons (copy-marker beg) (point-marker)))))) + (while (not (eolp)) + (forward-line)) + (cons (copy-marker beg) (point-marker)))))) (defun ledger-delete-current-entry () (interactive) diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el index 492f9467..da4a2806 100644 --- a/lisp/ldg-post.el +++ b/lisp/ldg-post.el @@ -26,14 +26,14 @@ (defun ledger-post-all-accounts () (let ((origin (point)) - (ledger-post-list nil) - account elements) + (ledger-post-list nil) + account elements) (save-excursion (goto-char (point-min)) (while (re-search-forward ledger-post-line-regexp nil t) - (unless (and (>= origin (match-beginning 0)) - (< origin (match-end 0))) - (add-to-list 'ledger-post-list (ledger-regex-post-line-account)))) + (unless (and (>= origin (match-beginning 0)) + (< origin (match-end 0))) + (add-to-list 'ledger-post-list (ledger-regex-post-line-account)))) (nreverse ledger-post-list)))) (declare-function iswitchb-read-buffer "iswitchb" @@ -47,9 +47,9 @@ to choose from." (cond (ledger-post-use-iswitchb (let* ((iswitchb-use-virtual-buffers nil) - (iswitchb-make-buflist-hook - (lambda () - (setq iswitchb-temp-buflist choices)))) + (iswitchb-make-buflist-hook + (lambda () + (setq iswitchb-temp-buflist choices)))) (iswitchb-read-buffer prompt))) (ledger-post-use-ido (ido-completing-read prompt choices)) @@ -61,26 +61,26 @@ to choose from." (defun ledger-post-pick-account () (interactive) (let* ((account - (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))) + (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 (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) - (insert (make-string (- existing-len account-len) ? ))) - ((< existing-len account-len) - (dotimes (n (- account-len existing-len)) - (if (looking-at "[ \t]\\( [ \t]\\|\t\\)") - (delete-char 1))))))) + (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) + (insert (make-string (- existing-len account-len) ? ))) + ((< existing-len account-len) + (dotimes (n (- account-len existing-len)) + (if (looking-at "[ \t]\\( [ \t]\\|\t\\)") + (delete-char 1))))))) (goto-char pos))) (defun ledger-next-amount (&optional end) @@ -88,7 +88,7 @@ to choose from." (goto-char (match-beginning 0)) (skip-syntax-forward " ") (- (or (match-end 4) - (match-end 3)) (point)))) + (match-end 3)) (point)))) (defun ledger-align-amounts (&optional column) "Align amounts in the current region. @@ -98,24 +98,24 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." (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) + (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)))))) + (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) @@ -130,7 +130,7 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." (when (< end (line-end-position)) (goto-char (line-beginning-position)) (if (looking-at ledger-post-line-regexp) - (ledger-post-align-amount))))) + (ledger-post-align-amount))))) (defun ledger-post-edit-amount () (interactive) @@ -139,12 +139,12 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." (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)) - (delete-region (match-beginning 0) (match-end 0)) - (calc) - (while (string-match "," val) - (setq val (replace-match "" nil nil val))) - (calc-eval val 'push))))) + (goto-char (match-beginning 0)) + (delete-region (match-beginning 0) (match-end 0)) + (calc) + (while (string-match "," val) + (setq val (replace-match "" nil nil val))) + (calc-eval val 'push))))) (defun ledger-post-prev-xact () (interactive) diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el index 3be882f4..baeadc33 100644 --- a/lisp/ldg-reconcile.el +++ b/lisp/ldg-reconcile.el @@ -5,41 +5,41 @@ (defun ledger-display-balance () (let ((buffer ledger-buf) - (account ledger-acct)) + (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)))))))) + (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) + (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))) + (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)))) + (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)))) + (line (count-lines (point-min) (point)))) (erase-buffer) (ledger-do-reconcile) (set-buffer-modified-p t) @@ -49,9 +49,9 @@ (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))))) + (with-current-buffer buf + (ledger-reconcile-refresh) + (set-buffer-modified-p nil))))) (defun ledger-reconcile-add () (interactive) @@ -64,12 +64,12 @@ (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)) + (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))))) + (goto-char (line-beginning-position)) + (delete-region (point) (1+ (line-end-position))) + (set-buffer-modified-p t))))) (defun ledger-reconcile-visit () (interactive) @@ -95,12 +95,12 @@ (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)))) + (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)) @@ -110,12 +110,12 @@ (defun ledger-reconcile (account) (interactive "sAccount to reconcile: ") (let ((buf (current-buffer)) - (rbuf (get-buffer "*Reconcile*"))) + (rbuf (get-buffer "*Reconcile*"))) (if rbuf - (kill-buffer rbuf)) + (kill-buffer rbuf)) (add-hook 'after-save-hook 'ledger-reconcile-refresh-after-save) (with-current-buffer - (pop-to-buffer (get-buffer-create "*Reconcile*")) + (pop-to-buffer (get-buffer-create "*Reconcile*")) (ledger-reconcile-mode) (set (make-local-variable 'ledger-buf) buf) (set (make-local-variable 'ledger-acct) account) diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el index 93ef6b09..1c6b8f06 100644 --- a/lisp/ldg-regex.el +++ b/lisp/ldg-regex.el @@ -6,112 +6,112 @@ (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) + (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))))) + (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)))) + (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))))) + (list + `(defconst ,(intern (concat "ledger-regex-" (symbol-name name) + "-group--count")) + ,(length args))))) (cons 'progn defs))) (put 'ledger-define-regexp 'lisp-indent-function 1) (ledger-define-regexp date - (let ((sep '(or ?- (any ?. ?/)))) ; can't do (any ?- ?. ?/) due to bug + (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)))))) + (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)))))) + (? (and ?= (regexp ,ledger-date-regexp)))))) "Match a compound date, of the form ACTUAL=EFFECTIVE" (actual date) (effective date)) @@ -126,7 +126,7 @@ (ledger-define-regexp long-space (rx (and (*? blank) - (or (and ? (or ? ?\t)) ?\t))) + (or (and ? (or ? ?\t)) ?\t))) "Match a \"long space\".") (ledger-define-regexp note @@ -136,24 +136,24 @@ (ledger-define-regexp end-note (macroexpand `(rx (and (regexp ,ledger-long-space-regexp) ?\; - (regexp ,ledger-note-regexp)))) + (regexp ,ledger-note-regexp)))) "") (ledger-define-regexp full-note (macroexpand `(rx (and line-start (+ blank) - ?\; (regexp ,ledger-note-regexp)))) + ?\; (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))) + (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) @@ -172,8 +172,8 @@ (ledger-define-regexp full-account (macroexpand `(rx (and (regexp ,ledger-account-kind-regexp) - (regexp ,ledger-account-regexp) - (? (any ?\] ?\)))))) + (regexp ,ledger-account-regexp) + (? (any ?\] ?\)))))) "" (kind account-kind) (name account)) @@ -181,50 +181,50 @@ (ledger-define-regexp commodity (rx (group (or (and ?\" (+ (not (any ?\"))) ?\") - (not (any blank ?\n - digit - ?- ?\[ ?\] - ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?= - ?\< ?\> ?\{ ?\} ?\( ?\) ?@))))) + (not (any blank ?\n + digit + ?- ?\[ ?\] + ?. ?, ?\; ?+ ?* ?/ ?^ ?? ?: ?& ?| ?! ?= + ?\< ?\> ?\{ ?\} ?\( ?\) ?@))))) "") (ledger-define-regexp amount (rx (group (and (? ?-) - (and (+ digit) - (*? (and (any ?. ?,) (+ digit)))) - (? (and (any ?. ?,) (+ digit)))))) + (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)))))) + (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 ?\))) ?\)))))) + (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)))) + (regexp ,ledger-commoditized-amount-regexp)))) "") (ledger-define-regexp balance-assertion (macroexpand `(rx (and ?= (+ blank) - (regexp ,ledger-commoditized-amount-regexp)))) + (regexp ,ledger-commoditized-amount-regexp)))) "") (ledger-define-regexp full-amount @@ -234,12 +234,12 @@ (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))) + (? (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 02e50de9..7b5c0d0a 100644 --- a/lisp/ldg-register.el +++ b/lisp/ldg-register.el @@ -25,29 +25,29 @@ (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))))) + (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)) ) @@ -55,10 +55,10 @@ (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)) + (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)))) diff --git a/lisp/ldg-report.el b/lisp/ldg-report.el index 6fc74f1d..5a668847 100644 --- a/lisp/ldg-report.el +++ b/lisp/ldg-report.el @@ -15,7 +15,7 @@ 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"))) + (string :tag "Command Line"))) :group 'ledger) (defcustom ledger-report-format-specifiers @@ -73,8 +73,8 @@ text that should replace the format specifier." The empty string and unknown names are allowed." (completing-read "Report name: " - ledger-reports nil nil nil - 'ledger-report-name-prompt-history nil)) + 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'. @@ -93,18 +93,18 @@ used to generate the buffer, navigating the buffer, etc." (interactive (progn (when (and (buffer-modified-p) - (y-or-n-p "Buffer modified, save it? ")) + (y-or-n-p "Buffer modified, save it? ")) (save-buffer)) (let ((rname (ledger-report-read-name)) - (edit (not (null current-prefix-arg)))) + (edit (not (null current-prefix-arg)))) (list rname edit)))) (let ((buf (current-buffer)) - (rbuf (get-buffer ledger-report-buffer-name)) - (wcfg (current-window-configuration))) + (rbuf (get-buffer ledger-report-buffer-name)) + (wcfg (current-window-configuration))) (if rbuf - (kill-buffer rbuf)) + (kill-buffer rbuf)) (with-current-buffer - (pop-to-buffer (get-buffer-create ledger-report-buffer-name)) + (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) @@ -137,8 +137,8 @@ If name exists, returns the object naming the report, otherwise returns nil." (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)) + (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 @@ -165,9 +165,9 @@ end of a ledger file which is included in some other file." (defun ledger-read-string-with-default (prompt default) (let ((default-prompt (concat prompt - (if default - (concat " (" default "): ") - ": ")))) + (if default + (concat " (" default "): ") + ": ")))) (read-string default-prompt nil nil default))) (defun ledger-report-payee-format-specifier () @@ -191,26 +191,26 @@ 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))) + (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))))) + (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) @@ -222,18 +222,18 @@ the default." (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)) + (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") + (format "Command: %s\n" cmd) + (make-string (- (window-width) 1) ?=) + "\n") (shell-command cmd t nil)) (defun ledger-report-goto () @@ -241,7 +241,7 @@ the default." (interactive) (let ((rbuf (get-buffer ledger-report-buffer-name))) (if (not rbuf) - (error "There is no ledger report buffer")) + (error "There is no ledger report buffer")) (pop-to-buffer rbuf) (shrink-window-if-larger-than-buffer))) @@ -277,7 +277,7 @@ the default." (let ((name "")) (while (string-empty-p name) (setq name (read-from-minibuffer "Report name: " nil nil nil - 'ledger-report-name-prompt-history))) + 'ledger-report-name-prompt-history))) name)) (defun ledger-report-save () @@ -290,15 +290,15 @@ the default." (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-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))) @@ -333,24 +333,24 @@ the default." 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) + 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)))))))) + (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 () @@ -363,40 +363,40 @@ the fields in the line in a association list." (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))))))) + (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. @@ -406,8 +406,8 @@ specified line, returns nil." (save-excursion (let ((left (forward-line offset))) (if (not (equal left 0)) - nil - (ledger-context-at-point))))) + nil + (ledger-context-at-point))))) (defun ledger-context-line-type (context-info) (nth 0 context-info)) @@ -444,5 +444,5 @@ specified line, returns nil." (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)))) + (ledger-context-field-value context-info 'payee) + nil)))) diff --git a/lisp/ldg-state.el b/lisp/ldg-state.el index 945d72fe..6a841621 100644 --- a/lisp/ldg-state.el +++ b/lisp/ldg-state.el @@ -6,28 +6,28 @@ (defun ledger-toggle-state (state &optional style) (if (not (null state)) (if (and style (eq style 'cleared)) - 'cleared) + 'cleared) (if (and style (eq style 'pending)) - 'pending + 'pending 'cleared))) (defun ledger-entry-state () (save-excursion (when (or (looking-at "^[0-9]") - (re-search-backward "^[0-9]" nil t)) + (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))))) + ((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))))) + ((looking-at "\\*\\s-*") 'cleared) + (t (ledger-entry-state))))) (defun ledger-toggle-current-transaction (&optional style) "Toggle the cleared status of the transaction under point. @@ -42,129 +42,129 @@ formatting, but doing so causes inline math expressions to be dropped." (interactive) (let ((bounds (ledger-current-entry-bounds)) - clear cleared) + 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))) + (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)))) + (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))))) + (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))))))) + (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))) + (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)) + (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) @@ -172,18 +172,18 @@ dropped." (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)))) + (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-texi.el b/lisp/ldg-texi.el index 982ea0ed..9d5383eb 100644 --- a/lisp/ldg-texi.el +++ b/lisp/ldg-texi.el @@ -5,13 +5,13 @@ (defun ledger-texi-write-test (name command input output &optional category) (let ((buf (current-buffer))) (with-current-buffer (find-file-noselect - (expand-file-name (concat name ".test") category)) + (expand-file-name (concat name ".test") category)) (erase-buffer) (let ((case-fold-search nil)) - (if (string-match "\\$LEDGER\\s-+" command) - (setq command (replace-match "" t t command))) - (if (string-match " -f \\$\\([-a-z]+\\)" command) - (setq command (replace-match "" t t command)))) + (if (string-match "\\$LEDGER\\s-+" command) + (setq command (replace-match "" t t command))) + (if (string-match " -f \\$\\([-a-z]+\\)" command) + (setq command (replace-match "" t t command)))) (insert command ?\n) (insert "<<<" ?\n) (insert input) @@ -21,13 +21,13 @@ (insert "=== 0" ?\n) (save-buffer) (unless (eq buf (current-buffer)) - (kill-buffer (current-buffer)))))) + (kill-buffer (current-buffer)))))) (defun ledger-texi-update-test () (interactive) (let ((details (ledger-texi-test-details)) - (name (file-name-sans-extension - (file-name-nondirectory (buffer-file-name))))) + (name (file-name-sans-extension + (file-name-nondirectory (buffer-file-name))))) (ledger-texi-write-test name (nth 0 details) (nth 1 details) @@ -39,30 +39,30 @@ (defun ledger-texi-test-details () (goto-char (point-min)) (let ((command (buffer-substring (point) (line-end-position))) - input output) + input output) (re-search-forward "^<<<") (let ((input-beg (1+ (match-end 0)))) (re-search-forward "^>>>1") (let ((output-beg (1+ (match-end 0)))) - (setq input (buffer-substring input-beg (match-beginning 0))) - (re-search-forward "^>>>2") - (setq output (buffer-substring output-beg (match-beginning 0))) - (list command input output))))) + (setq input (buffer-substring input-beg (match-beginning 0))) + (re-search-forward "^>>>2") + (setq output (buffer-substring output-beg (match-beginning 0))) + (list command input output))))) (defun ledger-texi-expand-command (command data-file) (if (string-match "\\$LEDGER" command) (replace-match (format "%s -f \"%s\" %s" ledger-path - data-file ledger-normalization-args) t t command) + data-file ledger-normalization-args) t t command) (concat (format "%s -f \"%s\" %s " ledger-path - data-file ledger-normalization-args) command))) + data-file ledger-normalization-args) command))) (defun ledger-texi-invoke-command (command) (with-temp-buffer (shell-command command t (current-buffer)) (if (= (point-min) (point-max)) - (progn - (push-mark nil t) - (message "Command '%s' yielded no result at %d" command (point)) - (ding)) + (progn + (push-mark nil t) + (message "Command '%s' yielded no result at %d" command (point)) + (ding)) (buffer-string)))) (defun ledger-texi-write-test-data (name input) @@ -79,43 +79,43 @@ (goto-char (point-min)) (while (re-search-forward "^@c \\(\\(?:sm\\)?ex\\) \\(\\S-+\\): \\(.*\\)" nil t) (let ((section (match-string 1)) - (example-name (match-string 2)) - (command (match-string 3)) expanded-command - (data-file ledger-sample-doc-path) - input output) - (goto-char (match-end 0)) - (forward-line) - (when (looking-at "@\\(\\(?:small\\)?example\\)") - (let ((beg (point))) - (re-search-forward "^@end \\(\\(?:small\\)?example\\)") - (delete-region beg (1+ (point))))) + (example-name (match-string 2)) + (command (match-string 3)) expanded-command + (data-file ledger-sample-doc-path) + input output) + (goto-char (match-end 0)) + (forward-line) + (when (looking-at "@\\(\\(?:small\\)?example\\)") + (let ((beg (point))) + (re-search-forward "^@end \\(\\(?:small\\)?example\\)") + (delete-region beg (1+ (point))))) - (when (let ((case-fold-search nil)) - (string-match " -f \\$\\([-a-z]+\\)" command)) - (let ((label (match-string 1 command))) - (setq command (replace-match "" t t command)) - (save-excursion - (goto-char (point-min)) - (search-forward (format "@c data: %s" label)) - (re-search-forward "@\\(\\(?:small\\)?example\\)") - (forward-line) - (let ((beg (point))) - (re-search-forward "@end \\(\\(?:small\\)?example\\)") - (setq data-file (ledger-texi-write-test-data - (format "%s.dat" label) - (buffer-substring-no-properties - beg (match-beginning 0)))))))) + (when (let ((case-fold-search nil)) + (string-match " -f \\$\\([-a-z]+\\)" command)) + (let ((label (match-string 1 command))) + (setq command (replace-match "" t t command)) + (save-excursion + (goto-char (point-min)) + (search-forward (format "@c data: %s" label)) + (re-search-forward "@\\(\\(?:small\\)?example\\)") + (forward-line) + (let ((beg (point))) + (re-search-forward "@end \\(\\(?:small\\)?example\\)") + (setq data-file (ledger-texi-write-test-data + (format "%s.dat" label) + (buffer-substring-no-properties + beg (match-beginning 0)))))))) - (let ((section-name (if (string= section "smex") - "smallexample" - "example")) - (output (ledger-texi-invoke-command - (ledger-texi-expand-command command data-file)))) - (insert "@" section-name ?\n output - "@end " section-name ?\n)) + (let ((section-name (if (string= section "smex") + "smallexample" + "example")) + (output (ledger-texi-invoke-command + (ledger-texi-expand-command command data-file)))) + (insert "@" section-name ?\n output + "@end " section-name ?\n)) - ;; Update the regression test associated with this example - (ledger-texi-write-test example-name command input output - "../test/manual"))))) + ;; Update the regression test associated with this example + (ledger-texi-write-test example-name command input output + "../test/manual"))))) (provide 'ldg-texi) diff --git a/lisp/ldg-xact.el b/lisp/ldg-xact.el index 5945632a..e1f165a7 100644 --- a/lisp/ldg-xact.el +++ b/lisp/ldg-xact.el @@ -9,12 +9,12 @@ 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))))) + (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)))))) + (forward-paragraph)))))) diff --git a/lisp/ledger.el b/lisp/ledger.el index 0e2f4b11..25bb485b 100644 --- a/lisp/ledger.el +++ b/lisp/ledger.el @@ -107,7 +107,7 @@ 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"))) + (string :tag "Command Line"))) :group 'ledger) (defcustom ledger-report-format-specifiers @@ -128,13 +128,13 @@ text that should replace the format specifier." (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-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)) @@ -155,88 +155,88 @@ customizable to ease retro-entry.") (defun ledger-iterate-entries (callback) (goto-char (point-min)) (let* ((now (current-time)) - (current-year (nth 5 (decode-time now)))) + (current-year (nth 5 (decode-time now)))) (while (not (eobp)) (when (looking-at - (concat "\\(Y\\s-+\\([0-9]+\\)\\|" - "\\([0-9]\\{4\\}+\\)?[./]?" - "\\([0-9]+\\)[./]\\([0-9]+\\)\\s-+" - "\\(\\*\\s-+\\)?\\(.+\\)\\)")) - (let ((found (match-string 2))) - (if found - (setq current-year (string-to-number found)) - (let ((start (match-beginning 0)) - (year (match-string 3)) - (month (string-to-number (match-string 4))) - (day (string-to-number (match-string 5))) - (mark (match-string 6)) - (desc (match-string 7))) - (if (and year (> (length year) 0)) - (setq year (string-to-number year))) - (funcall callback start - (encode-time 0 0 0 day month - (or year current-year)) - mark desc))))) + (concat "\\(Y\\s-+\\([0-9]+\\)\\|" + "\\([0-9]\\{4\\}+\\)?[./]?" + "\\([0-9]+\\)[./]\\([0-9]+\\)\\s-+" + "\\(\\*\\s-+\\)?\\(.+\\)\\)")) + (let ((found (match-string 2))) + (if found + (setq current-year (string-to-number found)) + (let ((start (match-beginning 0)) + (year (match-string 3)) + (month (string-to-number (match-string 4))) + (day (string-to-number (match-string 5))) + (mark (match-string 6)) + (desc (match-string 7))) + (if (and year (> (length year) 0)) + (setq year (string-to-number year))) + (funcall callback start + (encode-time 0 0 0 day month + (or year current-year)) + mark desc))))) (forward-line)))) (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))))) + (< (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))))) + (- (+ (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))))))) + (if (ledger-time-less-p moment date) + (throw 'found t))))))) (defun ledger-add-entry (entry-text &optional insert-at-point) (interactive (list (read-string "Entry: " (concat ledger-year "/" ledger-month "/")))) (let* ((args (with-temp-buffer - (insert entry-text) - (eshell-parse-arguments (point-min) (point-max)))) - (ledger-buf (current-buffer)) - exit-code) + (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))) + (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))) + (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)) + (re-search-backward "^[0-9]" nil t)) (let ((beg (point))) - (while (not (eolp)) - (forward-line)) - (cons (copy-marker beg) (point-marker)))))) + (while (not (eolp)) + (forward-line)) + (cons (copy-marker beg) (point-marker)))))) (defun ledger-delete-current-entry () (interactive) @@ -248,18 +248,18 @@ Return the difference in the format of a time value." (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)))) + (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)) (defun ledger-move-to-next-field () @@ -268,28 +268,28 @@ Return the difference in the format of a time value." (defun ledger-toggle-state (state &optional style) (if (not (null state)) (if (and style (eq style 'cleared)) - 'cleared) + 'cleared) (if (and style (eq style 'pending)) - 'pending + 'pending 'cleared))) (defun ledger-entry-state () (save-excursion (when (or (looking-at "^[0-9]") - (re-search-backward "^[0-9]" nil t)) + (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))))) + ((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))))) + ((looking-at "\\*\\s-*") 'cleared) + (t (ledger-entry-state))))) (defun ledger-toggle-current-transaction (&optional style) "Toggle the cleared status of the transaction under point. @@ -304,129 +304,129 @@ formatting, but doing so causes inline math expressions to be dropped." (interactive) (let ((bounds (ledger-current-entry-bounds)) - clear cleared) + 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))) + (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)))) + (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))))) + (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))))))) + (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))) + (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)) + (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))) (defvar ledger-mode-abbrev-table) @@ -440,7 +440,7 @@ dropped." (if (boundp 'font-lock-defaults) (set (make-local-variable 'font-lock-defaults) - '(ledger-font-lock-keywords nil t))) + '(ledger-font-lock-keywords nil t))) (set (make-local-variable 'pcomplete-parse-arguments-function) 'ledger-parse-arguments) @@ -475,41 +475,41 @@ dropped." (defun ledger-display-balance () (let ((buffer ledger-buf) - (account ledger-acct)) + (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)))))))) + (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) + (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))) + (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)))) + (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)))) + (line (count-lines (point-min) (point)))) (erase-buffer) (ledger-do-reconcile) (set-buffer-modified-p t) @@ -519,9 +519,9 @@ dropped." (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))))) + (with-current-buffer buf + (ledger-reconcile-refresh) + (set-buffer-modified-p nil))))) (defun ledger-reconcile-add () (interactive) @@ -534,12 +534,12 @@ dropped." (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)) + (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))))) + (goto-char (line-beginning-position)) + (delete-region (point) (1+ (line-end-position))) + (set-buffer-modified-p t))))) (defun ledger-reconcile-visit () (interactive) @@ -565,53 +565,53 @@ dropped." (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)))) + (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)))))))) + (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))))) + (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))) @@ -619,12 +619,12 @@ dropped." (defun ledger-reconcile (account) (interactive "sAccount to reconcile: ") (let ((buf (current-buffer)) - (rbuf (get-buffer "*Reconcile*"))) + (rbuf (get-buffer "*Reconcile*"))) (if rbuf - (kill-buffer rbuf)) + (kill-buffer rbuf)) (add-hook 'after-save-hook 'ledger-reconcile-refresh-after-save) (with-current-buffer - (pop-to-buffer (get-buffer-create "*Reconcile*")) + (pop-to-buffer (get-buffer-create "*Reconcile*")) (ledger-reconcile-mode) (set (make-local-variable 'ledger-buf) buf) (set (make-local-variable 'ledger-acct) account) @@ -681,24 +681,24 @@ dropped." 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) + 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)))))))) + (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 () @@ -711,40 +711,40 @@ the fields in the line in a association list." (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))))))) + (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. @@ -754,8 +754,8 @@ specified line, returns nil." (save-excursion (let ((left (forward-line offset))) (if (not (equal left 0)) - nil - (ledger-context-at-point))))) + nil + (ledger-context-at-point))))) (defun ledger-context-line-type (context-info) (nth 0 context-info)) @@ -792,8 +792,8 @@ specified line, returns nil." (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)))) + (ledger-context-field-value context-info 'payee) + nil)))) ;; Ledger report mode @@ -832,8 +832,8 @@ specified line, returns nil." The empty string and unknown names are allowed." (completing-read "Report name: " - ledger-reports nil nil nil - 'ledger-report-name-prompt-history nil)) + 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'. @@ -852,18 +852,18 @@ used to generate the buffer, navigating the buffer, etc." (interactive (progn (when (and (buffer-modified-p) - (y-or-n-p "Buffer modified, save it? ")) + (y-or-n-p "Buffer modified, save it? ")) (save-buffer)) (let ((rname (ledger-report-read-name)) - (edit (not (null current-prefix-arg)))) + (edit (not (null current-prefix-arg)))) (list rname edit)))) (let ((buf (current-buffer)) - (rbuf (get-buffer ledger-report-buffer-name)) - (wcfg (current-window-configuration))) + (rbuf (get-buffer ledger-report-buffer-name)) + (wcfg (current-window-configuration))) (if rbuf - (kill-buffer rbuf)) + (kill-buffer rbuf)) (with-current-buffer - (pop-to-buffer (get-buffer-create ledger-report-buffer-name)) + (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) @@ -896,8 +896,8 @@ If name exists, returns the object naming the report, otherwise returns nil." (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)) + (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 @@ -909,9 +909,9 @@ otherwise the current buffer file is used." (defun ledger-read-string-with-default (prompt default) (let ((default-prompt (concat prompt - (if default - (concat " (" default "): ") - ": ")))) + (if default + (concat " (" default "): ") + ": ")))) (read-string default-prompt nil nil default))) (defun ledger-report-payee-format-specifier () @@ -935,26 +935,26 @@ 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))) + (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))))) + (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) @@ -966,18 +966,18 @@ the default." (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)) + (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") + (format "Command: %s\n" cmd) + (make-string (- (window-width) 1) ?=) + "\n") (shell-command cmd t nil)) (defun ledger-report-goto () @@ -985,7 +985,7 @@ the default." (interactive) (let ((rbuf (get-buffer ledger-report-buffer-name))) (if (not rbuf) - (error "There is no ledger report buffer")) + (error "There is no ledger report buffer")) (pop-to-buffer rbuf) (shrink-window-if-larger-than-buffer))) @@ -1021,7 +1021,7 @@ the default." (let ((name "")) (while (string-empty-p name) (setq name (read-from-minibuffer "Report name: " nil nil nil - 'ledger-report-name-prompt-history))) + 'ledger-report-name-prompt-history))) name)) (defun ledger-report-save () @@ -1034,15 +1034,15 @@ the default." (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-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))) @@ -1053,46 +1053,46 @@ the default." (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)))))) + (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) + (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))) + (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) + 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))))) + (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) @@ -1103,100 +1103,100 @@ the default." (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))))))))) + "^[ \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)) + (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))) + (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)))) + (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))))) + (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) + 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 (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)))) + (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)))))) + (goto-char (match-end 0)))))) ;; A sample function for $ users @@ -1205,7 +1205,7 @@ the default." (goto-char (match-beginning 0)) (skip-syntax-forward " ") (- (or (match-end 4) - (match-end 3)) (point)))) + (match-end 3)) (point)))) (defun ledger-align-amounts (&optional column) "Align amounts in the current region. @@ -1215,24 +1215,24 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." (setq column 52)) (save-excursion (let* ((mark-first (< (mark) (point))) - (begin (if mark-first (mark) (point))) - (end (if mark-first (point-marker) (mark-marker))) - offset) + (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)))))) + (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)))))) (defalias 'ledger-align-dollars 'ledger-align-amounts) @@ -1247,14 +1247,14 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." 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))))) + (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)))))) + (forward-paragraph)))))) ;; General helper functions @@ -1269,13 +1269,13 @@ This is done so that the last digit falls in COLUMN, which defaults to 52." (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)))))))) + (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)) diff --git a/lisp/timeclock.el b/lisp/timeclock.el index 03159e94..2cafa8eb 100644 --- a/lisp/timeclock.el +++ b/lisp/timeclock.el @@ -135,10 +135,10 @@ that day has a length that is different from the norm." "*If non-nil, ask if the user wants to clock out before exiting Emacs. This variable only has effect if set with \\[customize]." :set (lambda (symbol value) - (if value - (add-hook 'kill-emacs-query-functions 'timeclock-query-out) - (remove-hook 'kill-emacs-query-functions 'timeclock-query-out)) - (setq timeclock-ask-before-exiting value)) + (if value + (add-hook 'kill-emacs-query-functions 'timeclock-query-out) + (remove-hook 'kill-emacs-query-functions 'timeclock-query-out)) + (setq timeclock-ask-before-exiting value)) :type 'boolean :group 'timeclock) @@ -160,27 +160,27 @@ while timeclock information is being displayed in the modeline has no effect. You should call the function `timeclock-modeline-display' with a positive argument to force an update." :set (lambda (symbol value) - (let ((currently-displaying - (and (boundp 'timeclock-modeline-display) - timeclock-modeline-display))) - ;; if we're changing to the state that - ;; `timeclock-modeline-display' is already using, don't - ;; bother toggling it. This happens on the initial loading - ;; of timeclock.el. - (if (and currently-displaying - (or (and value - (boundp 'display-time-hook) - (memq 'timeclock-update-modeline - display-time-hook)) - (and (not value) - timeclock-update-timer))) - (setq currently-displaying nil)) - (and currently-displaying - (set-variable 'timeclock-modeline-display nil)) - (setq timeclock-use-display-time value) - (and currently-displaying - (set-variable 'timeclock-modeline-display t)) - timeclock-use-display-time)) + (let ((currently-displaying + (and (boundp 'timeclock-modeline-display) + timeclock-modeline-display))) + ;; if we're changing to the state that + ;; `timeclock-modeline-display' is already using, don't + ;; bother toggling it. This happens on the initial loading + ;; of timeclock.el. + (if (and currently-displaying + (or (and value + (boundp 'display-time-hook) + (memq 'timeclock-update-modeline + display-time-hook)) + (and (not value) + timeclock-update-timer))) + (setq currently-displaying nil)) + (and currently-displaying + (set-variable 'timeclock-modeline-display nil)) + (setq timeclock-use-display-time value) + (and currently-displaying + (set-variable 'timeclock-modeline-display t)) + timeclock-use-display-time)) :type 'boolean :group 'timeclock :require 'time) @@ -281,39 +281,39 @@ display (non-nil means on)." (setq timeclock-mode-string "") (or global-mode-string (setq global-mode-string '(""))) (let ((on-p (if arg - (> (prefix-numeric-value arg) 0) - (not timeclock-modeline-display)))) + (> (prefix-numeric-value arg) 0) + (not timeclock-modeline-display)))) (if on-p - (progn - (or (memq 'timeclock-mode-string global-mode-string) - (setq global-mode-string - (append global-mode-string '(timeclock-mode-string)))) - (unless (memq 'timeclock-update-modeline timeclock-event-hook) - (add-hook 'timeclock-event-hook 'timeclock-update-modeline)) - (when timeclock-update-timer - (cancel-timer timeclock-update-timer) - (setq timeclock-update-timer nil)) - (if (boundp 'display-time-hook) - (remove-hook 'display-time-hook 'timeclock-update-modeline)) - (if timeclock-use-display-time - (progn - ;; Update immediately so there is a visible change - ;; on calling this function. - (if display-time-mode (timeclock-update-modeline) - (message "Activate `display-time-mode' to see \ + (progn + (or (memq 'timeclock-mode-string global-mode-string) + (setq global-mode-string + (append global-mode-string '(timeclock-mode-string)))) + (unless (memq 'timeclock-update-modeline timeclock-event-hook) + (add-hook 'timeclock-event-hook 'timeclock-update-modeline)) + (when timeclock-update-timer + (cancel-timer timeclock-update-timer) + (setq timeclock-update-timer nil)) + (if (boundp 'display-time-hook) + (remove-hook 'display-time-hook 'timeclock-update-modeline)) + (if timeclock-use-display-time + (progn + ;; Update immediately so there is a visible change + ;; on calling this function. + (if display-time-mode (timeclock-update-modeline) + (message "Activate `display-time-mode' to see \ timeclock information")) - (add-hook 'display-time-hook 'timeclock-update-modeline)) - (setq timeclock-update-timer - (run-at-time nil 60 'timeclock-update-modeline)))) + (add-hook 'display-time-hook 'timeclock-update-modeline)) + (setq timeclock-update-timer + (run-at-time nil 60 'timeclock-update-modeline)))) (setq global-mode-string - (delq 'timeclock-mode-string global-mode-string)) + (delq 'timeclock-mode-string global-mode-string)) (remove-hook 'timeclock-event-hook 'timeclock-update-modeline) (if (boundp 'display-time-hook) - (remove-hook 'display-time-hook - 'timeclock-update-modeline)) + (remove-hook 'display-time-hook + 'timeclock-update-modeline)) (when timeclock-update-timer - (cancel-timer timeclock-update-timer) - (setq timeclock-update-timer nil))) + (cancel-timer timeclock-update-timer) + (setq timeclock-update-timer nil))) (force-mode-line-update) (setq timeclock-modeline-display on-p))) @@ -323,8 +323,8 @@ timeclock information")) "Toggle modeline display of time remaining. You must modify via \\[customize] for this variable to have an effect." :set (lambda (symbol value) - (setq timeclock-modeline-display - (timeclock-modeline-display (or value 0)))) + (setq timeclock-modeline-display + (timeclock-modeline-display (or value 0)))) :type 'boolean :group 'timeclock :require 'timeclock) @@ -349,34 +349,34 @@ interactively -- call the function `timeclock-get-project-function' to discover the name of the project." (interactive (list (and current-prefix-arg - (if (numberp current-prefix-arg) - (* current-prefix-arg 60 60) - 0)))) + (if (numberp current-prefix-arg) + (* current-prefix-arg 60 60) + 0)))) (if (equal (car timeclock-last-event) "i") (error "You've already clocked in!") (unless timeclock-last-event (timeclock-reread-log)) ;; Either no log file, or day has rolled over. (unless (and timeclock-last-event - (equal (timeclock-time-to-date - (cadr timeclock-last-event)) - (timeclock-time-to-date (current-time)))) + (equal (timeclock-time-to-date + (cadr timeclock-last-event)) + (timeclock-time-to-date (current-time)))) (let ((workday (or (and (numberp arg) arg) - (and arg 0) - (and timeclock-get-workday-function - (funcall timeclock-get-workday-function)) - timeclock-workday))) - (run-hooks 'timeclock-first-in-hook) - ;; settle the discrepancy for the new day - (setq timeclock-discrepancy - (- (or timeclock-discrepancy 0) workday)) - (if (not (= workday timeclock-workday)) - (timeclock-log "h" (and (numberp arg) - (number-to-string arg)))))) + (and arg 0) + (and timeclock-get-workday-function + (funcall timeclock-get-workday-function)) + timeclock-workday))) + (run-hooks 'timeclock-first-in-hook) + ;; settle the discrepancy for the new day + (setq timeclock-discrepancy + (- (or timeclock-discrepancy 0) workday)) + (if (not (= workday timeclock-workday)) + (timeclock-log "h" (and (numberp arg) + (number-to-string arg)))))) (timeclock-log "i" (or project - (and timeclock-get-project-function - (or find-project (interactive-p)) - (funcall timeclock-get-project-function)))) + (and timeclock-get-project-function + (or find-project (interactive-p)) + (funcall timeclock-get-project-function)))) (run-hooks 'timeclock-in-hook))) ;;;###autoload @@ -397,12 +397,12 @@ discover the reason." (timeclock-log (if arg "O" "o") (or reason - (and timeclock-get-reason-function - (or find-reason (interactive-p)) - (funcall timeclock-get-reason-function)))) + (and timeclock-get-reason-function + (or find-reason (interactive-p)) + (funcall timeclock-get-reason-function)))) (run-hooks 'timeclock-out-hook) (if arg - (run-hooks 'timeclock-done-hook)))) + (run-hooks 'timeclock-done-hook)))) ;; Should today-only be removed in favour of timeclock-relative? - gm (defsubst timeclock-workday-remaining (&optional today-only) @@ -412,8 +412,8 @@ If TODAY-ONLY is non-nil, the value returned will be relative only to the time worked today, and not to past time." (let ((discrep (timeclock-find-discrep))) (if discrep - (- (if today-only (cadr discrep) - (car discrep))) + (- (if today-only (cadr discrep) + (car discrep))) 0.0))) ;;;###autoload @@ -424,24 +424,24 @@ If TODAY-ONLY is non-nil, the display will be relative only to time worked today, ignoring the time worked on previous days." (interactive "P") (let ((remainder (timeclock-workday-remaining)) ; today-only? - (last-in (equal (car timeclock-last-event) "i")) - status) + (last-in (equal (car timeclock-last-event) "i")) + status) (setq status - (format "Currently %s since %s (%s), %s %s, leave at %s" - (if last-in "IN" "OUT") - (if show-seconds - (format-time-string "%-I:%M:%S %p" - (nth 1 timeclock-last-event)) - (format-time-string "%-I:%M %p" - (nth 1 timeclock-last-event))) - (or (nth 2 timeclock-last-event) - (if last-in "**UNKNOWN**" "workday over")) - (timeclock-seconds-to-string remainder show-seconds t) - (if (> remainder 0) - "remaining" "over") - (timeclock-when-to-leave-string show-seconds today-only))) + (format "Currently %s since %s (%s), %s %s, leave at %s" + (if last-in "IN" "OUT") + (if show-seconds + (format-time-string "%-I:%M:%S %p" + (nth 1 timeclock-last-event)) + (format-time-string "%-I:%M %p" + (nth 1 timeclock-last-event))) + (or (nth 2 timeclock-last-event) + (if last-in "**UNKNOWN**" "workday over")) + (timeclock-seconds-to-string remainder show-seconds t) + (if (> remainder 0) + "remaining" "over") + (timeclock-when-to-leave-string show-seconds today-only))) (if (interactive-p) - (message status) + (message status) status))) ;;;###autoload @@ -477,7 +477,7 @@ Returns the new value of `timeclock-discrepancy'." timeclock-discrepancy) (defun timeclock-seconds-to-string (seconds &optional show-seconds - reverse-leader) + reverse-leader) "Convert SECONDS into a compact time string. If SHOW-SECONDS is non-nil, make the resolution of the return string include the second count. If REVERSE-LEADER is non-nil, it means to @@ -486,14 +486,14 @@ This is used when negative time values have an inverted meaning (such as with time remaining, where negative time really means overtime)." (if show-seconds (format "%s%d:%02d:%02d" - (if (< seconds 0) (if reverse-leader "+" "-") "") - (truncate (/ (abs seconds) 60 60)) - (% (truncate (/ (abs seconds) 60)) 60) - (% (truncate (abs seconds)) 60)) + (if (< seconds 0) (if reverse-leader "+" "-") "") + (truncate (/ (abs seconds) 60 60)) + (% (truncate (/ (abs seconds) 60)) 60) + (% (truncate (abs seconds)) 60)) (format "%s%d:%02d" - (if (< seconds 0) (if reverse-leader "+" "-") "") - (truncate (/ (abs seconds) 60 60)) - (% (truncate (/ (abs seconds) 60)) 60)))) + (if (< seconds 0) (if reverse-leader "+" "-") "") + (truncate (/ (abs seconds) 60 60)) + (% (truncate (/ (abs seconds) 60)) 60)))) (defsubst timeclock-currently-in-p () "Return non-nil if the user is currently clocked in." @@ -501,7 +501,7 @@ as with time remaining, where negative time really means overtime)." ;;;###autoload (defun timeclock-workday-remaining-string (&optional show-seconds - today-only) + today-only) "Return a string representing the amount of time left today. Display second resolution if SHOW-SECONDS is non-nil. If TODAY-ONLY is non-nil, the display will be relative only to time worked today. @@ -509,10 +509,10 @@ See `timeclock-relative' for more information about the meaning of \"relative to today\"." (interactive) (let ((string (timeclock-seconds-to-string - (timeclock-workday-remaining today-only) - show-seconds t))) + (timeclock-workday-remaining today-only) + show-seconds t))) (if (interactive-p) - (message string) + (message string) string))) (defsubst timeclock-workday-elapsed () @@ -522,7 +522,7 @@ time worked. The default is to return only the time that has elapsed so far today." (let ((discrep (timeclock-find-discrep))) (if discrep - (nth 2 discrep) + (nth 2 discrep) 0.0))) ;;;###autoload @@ -532,9 +532,9 @@ Display seconds resolution if SHOW-SECONDS is non-nil. If RELATIVE is non-nil, the amount returned will be relative to past time worked." (interactive) (let ((string (timeclock-seconds-to-string (timeclock-workday-elapsed) - show-seconds))) + show-seconds))) (if (interactive-p) - (message string) + (message string) string))) (defsubst timeclock-time-to-seconds (time) @@ -546,8 +546,8 @@ non-nil, the amount returned will be relative to past time worked." (defsubst timeclock-seconds-to-time (seconds) "Convert SECONDS (a floating point number) to an Emacs time structure." (list (floor seconds 65536) - (floor (mod seconds 65536)) - (floor (* (- seconds (ffloor seconds)) 1000000)))) + (floor (mod seconds 65536)) + (floor (* (- seconds (ffloor seconds)) 1000000)))) ;; Should today-only be removed in favour of timeclock-relative? - gm (defsubst timeclock-when-to-leave (&optional today-only) @@ -557,15 +557,15 @@ the time worked today, and not to past time." (timeclock-seconds-to-time (- (timeclock-time-to-seconds (current-time)) (let ((discrep (timeclock-find-discrep))) - (if discrep - (if today-only - (cadr discrep) - (car discrep)) - 0.0))))) + (if discrep + (if today-only + (cadr discrep) + (car discrep)) + 0.0))))) ;;;###autoload (defun timeclock-when-to-leave-string (&optional show-seconds - today-only) + today-only) "Return a string representing the end of today's workday. This string is relative to the value of `timeclock-workday'. If SHOW-SECONDS is non-nil, the value printed/returned will include @@ -574,12 +574,12 @@ relative only to the time worked today, and not to past time." ;; Should today-only be removed in favour of timeclock-relative? - gm (interactive) (let* ((then (timeclock-when-to-leave today-only)) - (string - (if show-seconds - (format-time-string "%-I:%M:%S %p" then) - (format-time-string "%-I:%M %p" then)))) + (string + (if show-seconds + (format-time-string "%-I:%M:%S %p" then) + (format-time-string "%-I:%M %p" then)))) (if (interactive-p) - (message string) + (message string) string))) ;;; Internal Functions: @@ -591,17 +591,17 @@ relative only to the time worked today, and not to past time." "A version of `completing-read' that works on both Emacs and XEmacs." (if (featurep 'xemacs) (let ((str (completing-read prompt alist))) - (if (or (null str) (= (length str) 0)) - default - str)) + (if (or (null str) (= (length str) 0)) + default + str)) (completing-read prompt alist nil nil nil nil default))) (defun timeclock-ask-for-project () "Ask the user for the project they are clocking into." (timeclock-completing-read (format "Clock into which project (default \"%s\"): " - (or timeclock-last-project - (car timeclock-project-list))) + (or timeclock-last-project + (car timeclock-project-list))) (mapcar 'list timeclock-project-list) (or timeclock-last-project (car timeclock-project-list)))) @@ -611,7 +611,7 @@ relative only to the time worked today, and not to past time." (defun timeclock-ask-for-reason () "Ask the user for the reason they are clocking out." (timeclock-completing-read "Reason for clocking out: " - (mapcar 'list timeclock-reason-list))) + (mapcar 'list timeclock-reason-list))) (defun timeclock-update-modeline () "Update the `timeclock-mode-string' displayed in the modeline. @@ -619,22 +619,22 @@ The value of `timeclock-relative' affects the display as described in that variable's documentation." (interactive) (let ((remainder (timeclock-workday-remaining (not timeclock-relative))) - (last-in (equal (car timeclock-last-event) "i"))) + (last-in (equal (car timeclock-last-event) "i"))) (when (and (< remainder 0) - (not (and timeclock-day-over - (equal timeclock-day-over - (timeclock-time-to-date - (current-time)))))) + (not (and timeclock-day-over + (equal timeclock-day-over + (timeclock-time-to-date + (current-time)))))) (setq timeclock-day-over - (timeclock-time-to-date (current-time))) + (timeclock-time-to-date (current-time))) (run-hooks 'timeclock-day-over-hook)) (setq timeclock-mode-string - (propertize - (format " %c%s%c " - (if last-in ?< ?[) - (timeclock-seconds-to-string remainder nil t) - (if last-in ?> ?])) - 'help-echo "timeclock: time remaining")))) + (propertize + (format " %c%s%c " + (if last-in ?< ?[) + (timeclock-seconds-to-string remainder nil t) + (if last-in ?> ?])) + 'help-echo "timeclock: time remaining")))) (put 'timeclock-mode-string 'risky-local-variable t) @@ -645,24 +645,24 @@ being logged for. Normally only \"in\" events specify a project." (with-current-buffer (find-file-noselect timeclock-file) (goto-char (point-max)) (if (not (bolp)) - (insert "\n")) + (insert "\n")) (let ((now (current-time))) (insert code " " - (format-time-string "%Y/%m/%d %H:%M:%S" now) - (or (and project - (stringp project) - (> (length project) 0) - (concat " " project)) - "") - "\n") + (format-time-string "%Y/%m/%d %H:%M:%S" now) + (or (and project + (stringp project) + (> (length project) 0) + (concat " " project)) + "") + "\n") (if (equal (downcase code) "o") - (setq timeclock-last-period - (- (timeclock-time-to-seconds now) - (timeclock-time-to-seconds - (cadr timeclock-last-event))) - timeclock-discrepancy - (+ timeclock-discrepancy - timeclock-last-period))) + (setq timeclock-last-period + (- (timeclock-time-to-seconds now) + (timeclock-time-to-seconds + (cadr timeclock-last-event))) + timeclock-discrepancy + (+ timeclock-discrepancy + timeclock-last-period))) (setq timeclock-last-event (list code now project))) (save-buffer) (run-hooks 'timeclock-event-hook) @@ -670,21 +670,21 @@ being logged for. Normally only \"in\" events specify a project." (defvar timeclock-moment-regexp (concat "\\([bhioO]\\)\\s-+" - "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)\\s-+" - "\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\)[ \t]*" "\\([^\n]*\\)")) + "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)\\s-+" + "\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\)[ \t]*" "\\([^\n]*\\)")) (defsubst timeclock-read-moment () "Read the moment under point from the timelog." (if (looking-at timeclock-moment-regexp) (let ((code (match-string 1)) - (year (string-to-number (match-string 2))) - (mon (string-to-number (match-string 3))) - (mday (string-to-number (match-string 4))) - (hour (string-to-number (match-string 5))) - (min (string-to-number (match-string 6))) - (sec (string-to-number (match-string 7))) - (project (match-string 8))) - (list code (encode-time sec min hour mday mon year) project)))) + (year (string-to-number (match-string 2))) + (mon (string-to-number (match-string 3))) + (mday (string-to-number (match-string 4))) + (hour (string-to-number (match-string 5))) + (min (string-to-number (match-string 6))) + (sec (string-to-number (match-string 7))) + (project (match-string 8))) + (list code (encode-time sec min hour mday mon year) project)))) (defun timeclock-last-period (&optional moment) "Return the value of the last event period. @@ -695,8 +695,8 @@ This is only provided for coherency when used by `timeclock-discrepancy'." (if (equal (car timeclock-last-event) "i") (- (timeclock-time-to-seconds (or moment (current-time))) - (timeclock-time-to-seconds - (cadr timeclock-last-event))) + (timeclock-time-to-seconds + (cadr timeclock-last-event))) timeclock-last-period)) (defsubst timeclock-entry-length (entry) @@ -741,9 +741,9 @@ This is only provided for coherency when used by (let (projects) (while entry-list (let ((project (timeclock-entry-project (car entry-list)))) - (if projects - (add-to-list 'projects project) - (setq projects (list project)))) + (if projects + (add-to-list 'projects project) + (setq projects (list project)))) (setq entry-list (cdr entry-list))) projects)) @@ -805,11 +805,11 @@ This is only provided for coherency when used by (let (projects) (while day-list (let ((projs (timeclock-day-projects (car day-list)))) - (while projs - (if projects - (add-to-list 'projects (car projs)) - (setq projects (list (car projs)))) - (setq projs (cdr projs)))) + (while projs + (if projects + (add-to-list 'projects (car projs)) + (setq projects (list (car projs)))) + (setq projs (cdr projs)))) (setq day-list (cdr day-list))) projects)) @@ -822,10 +822,10 @@ This is only provided for coherency when used by (defun timeclock-day-list (&optional log-data) (let ((alist (timeclock-day-alist log-data)) - day-list) + day-list) (while alist (setq day-list (cons (cdar alist) day-list) - alist (cdr alist))) + alist (cdr alist))) day-list)) (defsubst timeclock-project-alist (&optional log-data) @@ -963,73 +963,73 @@ lists: See the documentation for the given function if more info is needed." (let* ((log-data (list 0.0 nil nil)) - (now (current-time)) - (todays-date (timeclock-time-to-date now)) - last-date-limited last-date-seconds last-date - (line 0) last beg day entry event) + (now (current-time)) + (todays-date (timeclock-time-to-date now)) + last-date-limited last-date-seconds last-date + (line 0) last beg day entry event) (with-temp-buffer (insert-file-contents (or filename timeclock-file)) (when recent-only - (goto-char (point-max)) - (unless (re-search-backward "^b\\s-+" nil t) - (goto-char (point-min)))) + (goto-char (point-max)) + (unless (re-search-backward "^b\\s-+" nil t) + (goto-char (point-min)))) (while (or (setq event (timeclock-read-moment)) - (and beg (not last) - (setq last t event (list "o" now)))) - (setq line (1+ line)) - (cond ((equal (car event) "b") - (setcar log-data (string-to-number (nth 2 event)))) - ((equal (car event) "h") - (setq last-date-limited (timeclock-time-to-date (cadr event)) - last-date-seconds (* (string-to-number (nth 2 event)) - 3600.0))) - ((equal (car event) "i") - (if beg - (error "Error in format of timelog file, line %d" line) - (setq beg t)) - (setq entry (list (cadr event) nil - (and (> (length (nth 2 event)) 0) - (nth 2 event)))) - (let ((date (timeclock-time-to-date (cadr event)))) - (if (and last-date - (not (equal date last-date))) - (progn - (setcar (cdr log-data) - (cons (cons last-date day) - (cadr log-data))) - (setq day (list (and last-date-limited - last-date-seconds)))) - (unless day - (setq day (list (and last-date-limited - last-date-seconds))))) - (setq last-date date - last-date-limited nil))) - ((equal (downcase (car event)) "o") - (if (not beg) - (error "Error in format of timelog file, line %d" line) - (setq beg nil)) - (setcar (cdr entry) (cadr event)) - (let ((desc (and (> (length (nth 2 event)) 0) - (nth 2 event)))) - (if desc - (nconc entry (list (nth 2 event)))) - (if (equal (car event) "O") - (nconc entry (if desc - (list t) - (list nil t)))) - (nconc day (list entry)) - (setq desc (nth 2 entry)) - (let ((proj (assoc desc (nth 2 log-data)))) - (if (null proj) - (setcar (cddr log-data) - (cons (cons desc (list entry)) - (car (cddr log-data)))) - (nconc (cdr proj) (list entry))))))) - (forward-line)) + (and beg (not last) + (setq last t event (list "o" now)))) + (setq line (1+ line)) + (cond ((equal (car event) "b") + (setcar log-data (string-to-number (nth 2 event)))) + ((equal (car event) "h") + (setq last-date-limited (timeclock-time-to-date (cadr event)) + last-date-seconds (* (string-to-number (nth 2 event)) + 3600.0))) + ((equal (car event) "i") + (if beg + (error "Error in format of timelog file, line %d" line) + (setq beg t)) + (setq entry (list (cadr event) nil + (and (> (length (nth 2 event)) 0) + (nth 2 event)))) + (let ((date (timeclock-time-to-date (cadr event)))) + (if (and last-date + (not (equal date last-date))) + (progn + (setcar (cdr log-data) + (cons (cons last-date day) + (cadr log-data))) + (setq day (list (and last-date-limited + last-date-seconds)))) + (unless day + (setq day (list (and last-date-limited + last-date-seconds))))) + (setq last-date date + last-date-limited nil))) + ((equal (downcase (car event)) "o") + (if (not beg) + (error "Error in format of timelog file, line %d" line) + (setq beg nil)) + (setcar (cdr entry) (cadr event)) + (let ((desc (and (> (length (nth 2 event)) 0) + (nth 2 event)))) + (if desc + (nconc entry (list (nth 2 event)))) + (if (equal (car event) "O") + (nconc entry (if desc + (list t) + (list nil t)))) + (nconc day (list entry)) + (setq desc (nth 2 entry)) + (let ((proj (assoc desc (nth 2 log-data)))) + (if (null proj) + (setcar (cddr log-data) + (cons (cons desc (list entry)) + (car (cddr log-data)))) + (nconc (cdr proj) (list entry))))))) + (forward-line)) (if day - (setcar (cdr log-data) - (cons (cons last-date day) - (cadr log-data)))) + (setcar (cdr log-data) + (cons (cons last-date day) + (cadr log-data)))) log-data))) (defun timeclock-find-discrep () @@ -1050,82 +1050,82 @@ discrepancy, today's discrepancy, and the time worked today." ;; days (cdr days))) ;; total) (let* ((now (current-time)) - (todays-date (timeclock-time-to-date now)) - (first t) (accum 0) (elapsed 0) - event beg last-date avg - last-date-limited last-date-seconds) + (todays-date (timeclock-time-to-date now)) + (first t) (accum 0) (elapsed 0) + event beg last-date avg + last-date-limited last-date-seconds) (unless timeclock-discrepancy (when (file-readable-p timeclock-file) - (setq timeclock-project-list nil - timeclock-last-project nil - timeclock-reason-list nil - timeclock-elapsed 0) - (with-temp-buffer - (insert-file-contents timeclock-file) - (goto-char (point-max)) - (unless (re-search-backward "^b\\s-+" nil t) - (goto-char (point-min))) - (while (setq event (timeclock-read-moment)) - (cond ((equal (car event) "b") - (setq accum (string-to-number (nth 2 event)))) - ((equal (car event) "h") - (setq last-date-limited - (timeclock-time-to-date (cadr event)) - last-date-seconds - (* (string-to-number (nth 2 event)) 3600.0))) - ((equal (car event) "i") - (when (and (nth 2 event) - (> (length (nth 2 event)) 0)) - (add-to-list 'timeclock-project-list (nth 2 event)) - (setq timeclock-last-project (nth 2 event))) - (let ((date (timeclock-time-to-date (cadr event)))) - (if (if last-date - (not (equal date last-date)) - first) - (setq first nil - accum (- accum (if last-date-limited - last-date-seconds - timeclock-workday)))) - (setq last-date date - last-date-limited nil) - (if beg - (error "Error in format of timelog file!") - (setq beg (timeclock-time-to-seconds (cadr event)))))) - ((equal (downcase (car event)) "o") - (if (and (nth 2 event) - (> (length (nth 2 event)) 0)) - (add-to-list 'timeclock-reason-list (nth 2 event))) - (if (not beg) - (error "Error in format of timelog file!") - (setq timeclock-last-period - (- (timeclock-time-to-seconds (cadr event)) beg) - accum (+ timeclock-last-period accum) - beg nil)) - (if (equal last-date todays-date) - (setq timeclock-elapsed - (+ timeclock-last-period timeclock-elapsed))))) - (setq timeclock-last-event event - timeclock-last-event-workday - (if (equal (timeclock-time-to-date now) last-date-limited) - last-date-seconds - timeclock-workday)) - (forward-line)) - (setq timeclock-discrepancy accum)))) + (setq timeclock-project-list nil + timeclock-last-project nil + timeclock-reason-list nil + timeclock-elapsed 0) + (with-temp-buffer + (insert-file-contents timeclock-file) + (goto-char (point-max)) + (unless (re-search-backward "^b\\s-+" nil t) + (goto-char (point-min))) + (while (setq event (timeclock-read-moment)) + (cond ((equal (car event) "b") + (setq accum (string-to-number (nth 2 event)))) + ((equal (car event) "h") + (setq last-date-limited + (timeclock-time-to-date (cadr event)) + last-date-seconds + (* (string-to-number (nth 2 event)) 3600.0))) + ((equal (car event) "i") + (when (and (nth 2 event) + (> (length (nth 2 event)) 0)) + (add-to-list 'timeclock-project-list (nth 2 event)) + (setq timeclock-last-project (nth 2 event))) + (let ((date (timeclock-time-to-date (cadr event)))) + (if (if last-date + (not (equal date last-date)) + first) + (setq first nil + accum (- accum (if last-date-limited + last-date-seconds + timeclock-workday)))) + (setq last-date date + last-date-limited nil) + (if beg + (error "Error in format of timelog file!") + (setq beg (timeclock-time-to-seconds (cadr event)))))) + ((equal (downcase (car event)) "o") + (if (and (nth 2 event) + (> (length (nth 2 event)) 0)) + (add-to-list 'timeclock-reason-list (nth 2 event))) + (if (not beg) + (error "Error in format of timelog file!") + (setq timeclock-last-period + (- (timeclock-time-to-seconds (cadr event)) beg) + accum (+ timeclock-last-period accum) + beg nil)) + (if (equal last-date todays-date) + (setq timeclock-elapsed + (+ timeclock-last-period timeclock-elapsed))))) + (setq timeclock-last-event event + timeclock-last-event-workday + (if (equal (timeclock-time-to-date now) last-date-limited) + last-date-seconds + timeclock-workday)) + (forward-line)) + (setq timeclock-discrepancy accum)))) (unless timeclock-last-event-workday (setq timeclock-last-event-workday timeclock-workday)) (setq accum (or timeclock-discrepancy 0) - elapsed (or timeclock-elapsed elapsed)) + elapsed (or timeclock-elapsed elapsed)) (if timeclock-last-event - (if (equal (car timeclock-last-event) "i") - (let ((last-period (timeclock-last-period now))) - (setq accum (+ accum last-period) - elapsed (+ elapsed last-period))) - (if (not (equal (timeclock-time-to-date - (cadr timeclock-last-event)) - (timeclock-time-to-date now))) - (setq accum (- accum timeclock-last-event-workday))))) + (if (equal (car timeclock-last-event) "i") + (let ((last-period (timeclock-last-period now))) + (setq accum (+ accum last-period) + elapsed (+ elapsed last-period))) + (if (not (equal (timeclock-time-to-date + (cadr timeclock-last-event)) + (timeclock-time-to-date now))) + (setq accum (- accum timeclock-last-event-workday))))) (list accum (- elapsed timeclock-last-event-workday) - elapsed))) + elapsed))) ;;; A reporting function that uses timeclock-log-data @@ -1141,13 +1141,13 @@ If optional argument TIME is non-nil, use that instead of the current time." (defun timeclock-geometric-mean (l) "Compute the geometric mean of the values in the list L." (let ((total 0) - (count 0)) + (count 0)) (while l (setq total (+ total (car l)) - count (1+ count) - l (cdr l))) + count (1+ count) + l (cdr l))) (if (> count 0) - (/ total count) + (/ total count) 0))) (defun timeclock-generate-report (&optional html-p) @@ -1156,71 +1156,71 @@ By default, the report is in plain text, but if the optional argument HTML-P is non-nil, HTML markup is added." (interactive) (let ((log (timeclock-log-data)) - (today (timeclock-day-base))) + (today (timeclock-day-base))) (if html-p (insert "<p>")) (insert "Currently ") (let ((project (nth 2 timeclock-last-event)) - (begin (nth 1 timeclock-last-event)) - done) + (begin (nth 1 timeclock-last-event)) + done) (if (timeclock-currently-in-p) - (insert "IN") - (if (or (null project) (= (length project) 0)) - (progn (insert "Done Working Today") - (setq done t)) - (insert "OUT"))) + (insert "IN") + (if (or (null project) (= (length project) 0)) + (progn (insert "Done Working Today") + (setq done t)) + (insert "OUT"))) (unless done - (insert " since " (format-time-string "%Y/%m/%d %-I:%M %p" begin)) - (if html-p - (insert "<br>\n<b>") - (insert "\n*")) - (if (timeclock-currently-in-p) - (insert "Working on ")) - (if html-p - (insert project "</b><br>\n") - (insert project "*\n")) - (let ((proj-data (cdr (assoc project (timeclock-project-alist log)))) - (two-weeks-ago (timeclock-seconds-to-time - (- (timeclock-time-to-seconds today) - (* 2 7 24 60 60)))) - two-week-len today-len) - (while proj-data - (if (not (time-less-p - (timeclock-entry-begin (car proj-data)) today)) - (setq today-len (timeclock-entry-list-length proj-data) - proj-data nil) - (if (and (null two-week-len) - (not (time-less-p - (timeclock-entry-begin (car proj-data)) - two-weeks-ago))) - (setq two-week-len (timeclock-entry-list-length proj-data))) - (setq proj-data (cdr proj-data)))) - (if (null two-week-len) - (setq two-week-len today-len)) - (if html-p (insert "<p>")) - (if today-len - (insert "\nTime spent on this task today: " - (timeclock-seconds-to-string today-len) - ". In the last two weeks: " - (timeclock-seconds-to-string two-week-len)) - (if two-week-len - (insert "\nTime spent on this task in the last two weeks: " - (timeclock-seconds-to-string two-week-len)))) - (if html-p (insert "<br>")) - (insert "\n" - (timeclock-seconds-to-string (timeclock-workday-elapsed)) - " worked today, " - (timeclock-seconds-to-string (timeclock-workday-remaining)) - " remaining, done at " - (timeclock-when-to-leave-string) "\n"))) + (insert " since " (format-time-string "%Y/%m/%d %-I:%M %p" begin)) + (if html-p + (insert "<br>\n<b>") + (insert "\n*")) + (if (timeclock-currently-in-p) + (insert "Working on ")) + (if html-p + (insert project "</b><br>\n") + (insert project "*\n")) + (let ((proj-data (cdr (assoc project (timeclock-project-alist log)))) + (two-weeks-ago (timeclock-seconds-to-time + (- (timeclock-time-to-seconds today) + (* 2 7 24 60 60)))) + two-week-len today-len) + (while proj-data + (if (not (time-less-p + (timeclock-entry-begin (car proj-data)) today)) + (setq today-len (timeclock-entry-list-length proj-data) + proj-data nil) + (if (and (null two-week-len) + (not (time-less-p + (timeclock-entry-begin (car proj-data)) + two-weeks-ago))) + (setq two-week-len (timeclock-entry-list-length proj-data))) + (setq proj-data (cdr proj-data)))) + (if (null two-week-len) + (setq two-week-len today-len)) + (if html-p (insert "<p>")) + (if today-len + (insert "\nTime spent on this task today: " + (timeclock-seconds-to-string today-len) + ". In the last two weeks: " + (timeclock-seconds-to-string two-week-len)) + (if two-week-len + (insert "\nTime spent on this task in the last two weeks: " + (timeclock-seconds-to-string two-week-len)))) + (if html-p (insert "<br>")) + (insert "\n" + (timeclock-seconds-to-string (timeclock-workday-elapsed)) + " worked today, " + (timeclock-seconds-to-string (timeclock-workday-remaining)) + " remaining, done at " + (timeclock-when-to-leave-string) "\n"))) (if html-p (insert "<p>")) (insert "\nThere have been " - (number-to-string - (length (timeclock-day-alist log))) - " days of activity, starting " - (caar (last (timeclock-day-alist log)))) + (number-to-string + (length (timeclock-day-alist log))) + " days of activity, starting " + (caar (last (timeclock-day-alist log)))) (if html-p (insert "</p>")) (when html-p - (insert "<p> + (insert "<p> <table> <td width=\"25\"><br></td><td> <table border=1 cellpadding=3> @@ -1231,111 +1231,111 @@ HTML-P is non-nil, HTML markup is added." <th>-6 mons</th> <th>-1 year</th> </tr>") - (let* ((day-list (timeclock-day-list)) - (thirty-days-ago (timeclock-seconds-to-time - (- (timeclock-time-to-seconds today) - (* 30 24 60 60)))) - (three-months-ago (timeclock-seconds-to-time - (- (timeclock-time-to-seconds today) - (* 90 24 60 60)))) - (six-months-ago (timeclock-seconds-to-time - (- (timeclock-time-to-seconds today) - (* 180 24 60 60)))) - (one-year-ago (timeclock-seconds-to-time - (- (timeclock-time-to-seconds today) - (* 365 24 60 60)))) - (time-in (vector (list t) (list t) (list t) (list t) (list t))) - (time-out (vector (list t) (list t) (list t) (list t) (list t))) - (breaks (vector (list t) (list t) (list t) (list t) (list t))) - (workday (vector (list t) (list t) (list t) (list t) (list t))) - (lengths (vector '(0 0) thirty-days-ago three-months-ago - six-months-ago one-year-ago))) - ;; collect statistics from complete timelog - (while day-list - (let ((i 0) (l 5)) - (while (< i l) - (unless (time-less-p - (timeclock-day-begin (car day-list)) - (aref lengths i)) - (let ((base (timeclock-time-to-seconds - (timeclock-day-base - (timeclock-day-begin (car day-list)))))) - (nconc (aref time-in i) - (list (- (timeclock-time-to-seconds - (timeclock-day-begin (car day-list))) - base))) - (let ((span (timeclock-day-span (car day-list))) - (len (timeclock-day-length (car day-list))) - (req (timeclock-day-required (car day-list)))) - ;; If the day's actual work length is less than - ;; 70% of its span, then likely the exit time - ;; and break amount are not worthwhile adding to - ;; the statistic - (when (and (> span 0) - (> (/ (float len) (float span)) 0.70)) - (nconc (aref time-out i) - (list (- (timeclock-time-to-seconds - (timeclock-day-end (car day-list))) - base))) - (nconc (aref breaks i) (list (- span len)))) - (if req - (setq len (+ len (- timeclock-workday req)))) - (nconc (aref workday i) (list len))))) - (setq i (1+ i)))) - (setq day-list (cdr day-list))) - ;; average statistics - (let ((i 0) (l 5)) - (while (< i l) - (aset time-in i (timeclock-geometric-mean - (cdr (aref time-in i)))) - (aset time-out i (timeclock-geometric-mean - (cdr (aref time-out i)))) - (aset breaks i (timeclock-geometric-mean - (cdr (aref breaks i)))) - (aset workday i (timeclock-geometric-mean - (cdr (aref workday i)))) - (setq i (1+ i)))) - ;; Output the HTML table - (insert "<tr>\n") - (insert "<td align=\"center\">Time in</td>\n") - (let ((i 0) (l 5)) - (while (< i l) - (insert "<td align=\"right\">" - (timeclock-seconds-to-string (aref time-in i)) - "</td>\n") - (setq i (1+ i)))) - (insert "</tr>\n") - - (insert "<tr>\n") - (insert "<td align=\"center\">Time out</td>\n") - (let ((i 0) (l 5)) - (while (< i l) - (insert "<td align=\"right\">" - (timeclock-seconds-to-string (aref time-out i)) - "</td>\n") - (setq i (1+ i)))) - (insert "</tr>\n") - - (insert "<tr>\n") - (insert "<td align=\"center\">Break</td>\n") - (let ((i 0) (l 5)) - (while (< i l) - (insert "<td align=\"right\">" - (timeclock-seconds-to-string (aref breaks i)) - "</td>\n") - (setq i (1+ i)))) - (insert "</tr>\n") - - (insert "<tr>\n") - (insert "<td align=\"center\">Workday</td>\n") - (let ((i 0) (l 5)) - (while (< i l) - (insert "<td align=\"right\">" - (timeclock-seconds-to-string (aref workday i)) - "</td>\n") - (setq i (1+ i)))) - (insert "</tr>\n")) - (insert "<tfoot> + (let* ((day-list (timeclock-day-list)) + (thirty-days-ago (timeclock-seconds-to-time + (- (timeclock-time-to-seconds today) + (* 30 24 60 60)))) + (three-months-ago (timeclock-seconds-to-time + (- (timeclock-time-to-seconds today) + (* 90 24 60 60)))) + (six-months-ago (timeclock-seconds-to-time + (- (timeclock-time-to-seconds today) + (* 180 24 60 60)))) + (one-year-ago (timeclock-seconds-to-time + (- (timeclock-time-to-seconds today) + (* 365 24 60 60)))) + (time-in (vector (list t) (list t) (list t) (list t) (list t))) + (time-out (vector (list t) (list t) (list t) (list t) (list t))) + (breaks (vector (list t) (list t) (list t) (list t) (list t))) + (workday (vector (list t) (list t) (list t) (list t) (list t))) + (lengths (vector '(0 0) thirty-days-ago three-months-ago + six-months-ago one-year-ago))) + ;; collect statistics from complete timelog + (while day-list + (let ((i 0) (l 5)) + (while (< i l) + (unless (time-less-p + (timeclock-day-begin (car day-list)) + (aref lengths i)) + (let ((base (timeclock-time-to-seconds + (timeclock-day-base + (timeclock-day-begin (car day-list)))))) + (nconc (aref time-in i) + (list (- (timeclock-time-to-seconds + (timeclock-day-begin (car day-list))) + base))) + (let ((span (timeclock-day-span (car day-list))) + (len (timeclock-day-length (car day-list))) + (req (timeclock-day-required (car day-list)))) + ;; If the day's actual work length is less than + ;; 70% of its span, then likely the exit time + ;; and break amount are not worthwhile adding to + ;; the statistic + (when (and (> span 0) + (> (/ (float len) (float span)) 0.70)) + (nconc (aref time-out i) + (list (- (timeclock-time-to-seconds + (timeclock-day-end (car day-list))) + base))) + (nconc (aref breaks i) (list (- span len)))) + (if req + (setq len (+ len (- timeclock-workday req)))) + (nconc (aref workday i) (list len))))) + (setq i (1+ i)))) + (setq day-list (cdr day-list))) + ;; average statistics + (let ((i 0) (l 5)) + (while (< i l) + (aset time-in i (timeclock-geometric-mean + (cdr (aref time-in i)))) + (aset time-out i (timeclock-geometric-mean + (cdr (aref time-out i)))) + (aset breaks i (timeclock-geometric-mean + (cdr (aref breaks i)))) + (aset workday i (timeclock-geometric-mean + (cdr (aref workday i)))) + (setq i (1+ i)))) + ;; Output the HTML table + (insert "<tr>\n") + (insert "<td align=\"center\">Time in</td>\n") + (let ((i 0) (l 5)) + (while (< i l) + (insert "<td align=\"right\">" + (timeclock-seconds-to-string (aref time-in i)) + "</td>\n") + (setq i (1+ i)))) + (insert "</tr>\n") + + (insert "<tr>\n") + (insert "<td align=\"center\">Time out</td>\n") + (let ((i 0) (l 5)) + (while (< i l) + (insert "<td align=\"right\">" + (timeclock-seconds-to-string (aref time-out i)) + "</td>\n") + (setq i (1+ i)))) + (insert "</tr>\n") + + (insert "<tr>\n") + (insert "<td align=\"center\">Break</td>\n") + (let ((i 0) (l 5)) + (while (< i l) + (insert "<td align=\"right\">" + (timeclock-seconds-to-string (aref breaks i)) + "</td>\n") + (setq i (1+ i)))) + (insert "</tr>\n") + + (insert "<tr>\n") + (insert "<td align=\"center\">Workday</td>\n") + (let ((i 0) (l 5)) + (while (< i l) + (insert "<td align=\"right\">" + (timeclock-seconds-to-string (aref workday i)) + "</td>\n") + (setq i (1+ i)))) + (insert "</tr>\n")) + (insert "<tfoot> <td colspan=\"6\" align=\"center\"> <i>These are approximate figures</i></td> </tfoot> diff --git a/src/account.cc b/src/account.cc index 37ff83f3..4170a4d2 100644 --- a/src/account.cc +++ b/src/account.cc @@ -44,14 +44,14 @@ account_t::~account_t() foreach (accounts_map::value_type& pair, accounts) { if (! pair.second->has_flags(ACCOUNT_TEMP) || - has_flags(ACCOUNT_TEMP)) { + has_flags(ACCOUNT_TEMP)) { checked_delete(pair.second); } } } account_t * account_t::find_account(const string& name, - const bool auto_create) + const bool auto_create) { accounts_map::const_iterator i = accounts.find(name); if (i != accounts.end()) @@ -111,7 +111,7 @@ namespace { foreach (accounts_map::value_type& pair, account->accounts) if (account_t * a = find_account_re_(pair.second, regexp)) - return a; + return a; return NULL; } @@ -135,13 +135,13 @@ string account_t::fullname() const if (! _fullname.empty()) { return _fullname; } else { - const account_t * first = this; - string fullname = name; + const account_t * first = this; + string fullname = name; while (first->parent) { first = first->parent; if (! first->name.empty()) - fullname = first->name + ":" + fullname; + fullname = first->name + ":" + fullname; } _fullname = fullname; @@ -161,7 +161,7 @@ string account_t::partial_name(bool flat) const std::size_t count = acct->children_with_flags(ACCOUNT_EXT_TO_DISPLAY); assert(count > 0); if (count > 1 || acct->has_xflags(ACCOUNT_EXT_TO_DISPLAY)) - break; + break; } pname = acct->name + ":" + pname; } @@ -179,7 +179,7 @@ namespace { { in_context_t<account_t> env(scope, "&b"); return string_value(env->partial_name(env.has(0) ? - env.get<bool>(0) : false)); + env.get<bool>(0) : false)); } value_t get_account(account_t& account) { // this gets the name @@ -230,12 +230,12 @@ namespace { { std::size_t depth = 0; for (const account_t * acct = account.parent; - acct && acct->parent; - acct = acct->parent) { + acct && acct->parent; + acct = acct->parent) { std::size_t count = acct->children_with_flags(ACCOUNT_EXT_TO_DISPLAY); assert(count > 0); if (count > 1 || acct->has_xflags(ACCOUNT_EXT_TO_DISPLAY)) - depth++; + depth++; } std::ostringstream out; @@ -269,7 +269,7 @@ namespace { foreach (post_t * p, account.posts) { bind_scope_t bound_scope(scope, *p); if (expr.calc(bound_scope).to_boolean()) - return true; + return true; } return false; } @@ -284,14 +284,14 @@ namespace { foreach (post_t * p, account.posts) { bind_scope_t bound_scope(scope, *p); if (! expr.calc(bound_scope).to_boolean()) - return false; + return false; } return true; } } expr_t::ptr_op_t account_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (kind != symbol_t::FUNCTION) return NULL; @@ -407,7 +407,7 @@ bool account_t::children_with_xdata() const { foreach (const accounts_map::value_type& pair, accounts) if (pair.second->has_xdata() || - pair.second->children_with_xdata()) + pair.second->children_with_xdata()) return true; return false; @@ -420,7 +420,7 @@ std::size_t account_t::children_with_flags(xdata_t::flags_t flags) const foreach (const accounts_map::value_type& pair, accounts) if (pair.second->has_xflags(flags) || - pair.second->children_with_flags(flags)) + pair.second->children_with_flags(flags)) count++; // Although no immediately children were visited, if any progeny at all were @@ -434,11 +434,11 @@ std::size_t account_t::children_with_flags(xdata_t::flags_t flags) const account_t::xdata_t::details_t& account_t::xdata_t::details_t::operator+=(const details_t& other) { - posts_count += other.posts_count; - posts_virtuals_count += other.posts_virtuals_count; - posts_cleared_count += other.posts_cleared_count; - posts_last_7_count += other.posts_last_7_count; - posts_last_30_count += other.posts_last_30_count; + posts_count += other.posts_count; + posts_virtuals_count += other.posts_virtuals_count; + posts_cleared_count += other.posts_cleared_count; + posts_last_7_count += other.posts_last_7_count; + posts_last_30_count += other.posts_last_30_count; posts_this_month_count += other.posts_this_month_count; if (! is_valid(earliest_post) || @@ -461,9 +461,9 @@ account_t::xdata_t::details_t::operator+=(const details_t& other) filenames.insert(other.filenames.begin(), other.filenames.end()); accounts_referenced.insert(other.accounts_referenced.begin(), - other.accounts_referenced.end()); + other.accounts_referenced.end()); payees_referenced.insert(other.payees_referenced.begin(), - other.payees_referenced.end()); + other.payees_referenced.end()); return *this; } @@ -487,10 +487,10 @@ value_t account_t::amount(const optional<expr_t&>& expr) const for (; i != posts.end(); i++) { if ((*i)->xdata().has_flags(POST_EXT_VISITED)) { - if (! (*i)->xdata().has_flags(POST_EXT_CONSIDERED)) { - (*i)->add_to_value(xdata_->self_details.total, expr); - (*i)->xdata().add_flags(POST_EXT_CONSIDERED); - } + if (! (*i)->xdata().has_flags(POST_EXT_CONSIDERED)) { + (*i)->add_to_value(xdata_->self_details.total, expr); + (*i)->xdata().add_flags(POST_EXT_CONSIDERED); + } } xdata_->self_details.last_post = i; } @@ -502,10 +502,10 @@ value_t account_t::amount(const optional<expr_t&>& expr) const for (; i != xdata_->reported_posts.end(); i++) { if ((*i)->xdata().has_flags(POST_EXT_VISITED)) { - if (! (*i)->xdata().has_flags(POST_EXT_CONSIDERED)) { - (*i)->add_to_value(xdata_->self_details.total, expr); - (*i)->xdata().add_flags(POST_EXT_CONSIDERED); - } + if (! (*i)->xdata().has_flags(POST_EXT_CONSIDERED)) { + (*i)->add_to_value(xdata_->self_details.total, expr); + (*i)->xdata().add_flags(POST_EXT_CONSIDERED); + } } xdata_->self_details.last_reported_post = i; } @@ -525,7 +525,7 @@ value_t account_t::total(const optional<expr_t&>& expr) const foreach (const accounts_map::value_type& pair, accounts) { temp = pair.second->total(expr); if (! temp.is_null()) - add_or_set_value(xdata_->family_details.total, temp); + add_or_set_value(xdata_->family_details.total, temp); } temp = amount(expr); @@ -562,7 +562,7 @@ account_t::family_details(bool gather_all) const } void account_t::xdata_t::details_t::update(post_t& post, - bool gather_all) + bool gather_all) { posts_count++; @@ -592,10 +592,10 @@ void account_t::xdata_t::details_t::update(post_t& post, posts_cleared_count++; if (! is_valid(earliest_cleared_post) || - post.date() < earliest_cleared_post) + post.date() < earliest_cleared_post) earliest_cleared_post = post.date(); if (! is_valid(latest_cleared_post) || - post.date() > latest_cleared_post) + post.date() > latest_cleared_post) latest_cleared_post = post.date(); } diff --git a/src/account.h b/src/account.h index 0a3a75e4..d22d2bb3 100644 --- a/src/account.h +++ b/src/account.h @@ -55,24 +55,24 @@ typedef std::map<const string, account_t *> accounts_map; class account_t : public supports_flags<>, public scope_t { -#define ACCOUNT_NORMAL 0x00 // no flags at all, a basic account -#define ACCOUNT_KNOWN 0x01 -#define ACCOUNT_TEMP 0x02 // account is a temporary object -#define ACCOUNT_GENERATED 0x04 // account never actually existed +#define ACCOUNT_NORMAL 0x00 // no flags at all, a basic account +#define ACCOUNT_KNOWN 0x01 +#define ACCOUNT_TEMP 0x02 // account is a temporary object +#define ACCOUNT_GENERATED 0x04 // account never actually existed public: - account_t * parent; - string name; + account_t * parent; + string name; optional<string> note; unsigned short depth; - accounts_map accounts; - posts_list posts; + accounts_map accounts; + posts_list posts; mutable string _fullname; account_t(account_t * _parent = NULL, - const string& _name = "", - const optional<string>& _note = none) + const string& _name = "", + const optional<string>& _note = none) : supports_flags<>(), scope_t(), parent(_parent), name(_name), note(_note), depth(static_cast<unsigned short>(parent ? parent->depth + 1 : 0)) { @@ -107,7 +107,7 @@ public: account_t * find_account_re(const string& regexp); typedef transform_iterator<function<account_t *(accounts_map::value_type&)>, - accounts_map::iterator> + accounts_map::iterator> accounts_map_seconds_iterator; accounts_map_seconds_iterator accounts_begin() { @@ -132,7 +132,7 @@ public: } virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); bool valid() const; @@ -140,50 +140,50 @@ public: struct xdata_t : public supports_flags<> { -#define ACCOUNT_EXT_SORT_CALC 0x01 +#define ACCOUNT_EXT_SORT_CALC 0x01 #define ACCOUNT_EXT_HAS_NON_VIRTUALS 0x02 #define ACCOUNT_EXT_HAS_UNB_VIRTUALS 0x04 #define ACCOUNT_EXT_AUTO_VIRTUALIZE 0x08 #define ACCOUNT_EXT_VISITED 0x10 #define ACCOUNT_EXT_MATCHING 0x20 -#define ACCOUNT_EXT_TO_DISPLAY 0x40 -#define ACCOUNT_EXT_DISPLAYED 0x80 +#define ACCOUNT_EXT_TO_DISPLAY 0x40 +#define ACCOUNT_EXT_DISPLAYED 0x80 struct details_t { - value_t total; - bool calculated; - bool gathered; - - std::size_t posts_count; - std::size_t posts_virtuals_count; - std::size_t posts_cleared_count; - std::size_t posts_last_7_count; - std::size_t posts_last_30_count; - std::size_t posts_this_month_count; - - date_t earliest_post; - date_t earliest_cleared_post; - date_t latest_post; - date_t latest_cleared_post; - - std::set<path> filenames; - std::set<string> accounts_referenced; - std::set<string> payees_referenced; + value_t total; + bool calculated; + bool gathered; + + std::size_t posts_count; + std::size_t posts_virtuals_count; + std::size_t posts_cleared_count; + std::size_t posts_last_7_count; + std::size_t posts_last_30_count; + std::size_t posts_this_month_count; + + date_t earliest_post; + date_t earliest_cleared_post; + date_t latest_post; + date_t latest_cleared_post; + + std::set<path> filenames; + std::set<string> accounts_referenced; + std::set<string> payees_referenced; optional<posts_list::const_iterator> last_post; optional<posts_list::const_iterator> last_reported_post; details_t() - : calculated(false), - gathered(false), + : calculated(false), + gathered(false), - posts_count(0), - posts_virtuals_count(0), - posts_cleared_count(0), - posts_last_7_count(0), - posts_last_30_count(0), - posts_this_month_count(0) {} + posts_count(0), + posts_virtuals_count(0), + posts_cleared_count(0), + posts_last_7_count(0), + posts_last_30_count(0), + posts_this_month_count(0) {} details_t& operator+=(const details_t& other); @@ -202,9 +202,9 @@ public: } xdata_t(const xdata_t& other) : supports_flags<>(other.flags()), - self_details(other.self_details), - family_details(other.family_details), - sort_values(other.sort_values) + self_details(other.self_details), + family_details(other.family_details), + sort_values(other.sort_values) { TRACE_CTOR(account_t::xdata_t, "copy"); } diff --git a/src/accum.cc b/src/accum.cc index 55f5f0a4..157f459d 100644 --- a/src/accum.cc +++ b/src/accum.cc @@ -49,17 +49,17 @@ std::streamsize straccbuf::xsputn(const char * s, std::streamsize num) bool matched = false; for (const char * p = str.c_str(); *p; p++) { if (*p == '%') { - const char * q = p + 1; - if (*q && *q != '%' && std::isdigit(*q) && - std::string::size_type(*q - '0') == index) { - p++; - buf << std::string(s, num); - matched = true; - } else { - buf << *p; - } + const char * q = p + 1; + if (*q && *q != '%' && std::isdigit(*q) && + std::string::size_type(*q - '0') == index) { + p++; + buf << std::string(s, num); + matched = true; + } else { + buf << *p; + } } else { - buf << *p; + buf << *p; } } if (! matched) diff --git a/src/accum.h b/src/accum.h index cf74cb74..236a7714 100644 --- a/src/accum.h +++ b/src/accum.h @@ -47,7 +47,7 @@ namespace ledger { class straccbuf : public std::streambuf { protected: - std::string str; // accumulator + std::string str; // accumulator std::string::size_type index; public: diff --git a/src/amount.cc b/src/amount.cc index 01caf4ac..9817f464 100644 --- a/src/amount.cc +++ b/src/amount.cc @@ -56,8 +56,8 @@ struct amount_t::bigint_t : public supports_flags<> #define BIGINT_BULK_ALLOC 0x01 #define BIGINT_KEEP_PREC 0x02 - mpq_t val; - precision_t prec; + mpq_t val; + precision_t prec; uint_least32_t refc; #define MP(bigint) ((bigint)->val) @@ -68,7 +68,7 @@ struct amount_t::bigint_t : public supports_flags<> } bigint_t(const bigint_t& other) : supports_flags<>(static_cast<uint_least8_t> - (other.flags() & ~BIGINT_BULK_ALLOC)), + (other.flags() & ~BIGINT_BULK_ALLOC)), prec(other.prec), refc(1) { TRACE_CTOR(bigint_t, "copy"); mpq_init(val); @@ -87,7 +87,7 @@ struct amount_t::bigint_t : public supports_flags<> } if (flags() & ~(BIGINT_BULK_ALLOC | BIGINT_KEEP_PREC)) { DEBUG("ledger.validate", - "amount_t::bigint_t: flags() & ~(BULK_ALLOC | KEEP_PREC)"); + "amount_t::bigint_t: flags() & ~(BULK_ALLOC | KEEP_PREC)"); return false; } return true; @@ -111,18 +111,18 @@ private: bool amount_t::is_initialized = false; namespace { - void stream_out_mpq(std::ostream& out, - mpq_t quant, - amount_t::precision_t precision, - int zeros_prec = -1, - const optional<commodity_t&>& comm = none) + void stream_out_mpq(std::ostream& out, + mpq_t quant, + amount_t::precision_t precision, + int zeros_prec = -1, + const optional<commodity_t&>& comm = none) { char * buf = NULL; try { IF_DEBUG("amount.convert") { - char * tbuf = mpq_get_str(NULL, 10, quant); - DEBUG("amount.convert", "Rational to convert = " << tbuf); - std::free(tbuf); + char * tbuf = mpq_get_str(NULL, 10, quant); + DEBUG("amount.convert", "Rational to convert = " << tbuf); + std::free(tbuf); } // Convert the rational number to a floating-point, extending the @@ -131,7 +131,7 @@ namespace { mp_prec_t num_prec = mpz_sizeinbase(mpq_numref(quant), 2); num_prec += amount_t::extend_by_digits*64; if (num_prec < MPFR_PREC_MIN) - num_prec = MPFR_PREC_MIN; + num_prec = MPFR_PREC_MIN; DEBUG("amount.convert", "num prec = " << num_prec); mpfr_set_prec(tempfnum, num_prec); @@ -140,7 +140,7 @@ namespace { mp_prec_t den_prec = mpz_sizeinbase(mpq_denref(quant), 2); den_prec += amount_t::extend_by_digits*64; if (den_prec < MPFR_PREC_MIN) - den_prec = MPFR_PREC_MIN; + den_prec = MPFR_PREC_MIN; DEBUG("amount.convert", "den prec = " << den_prec); mpfr_set_prec(tempfden, den_prec); @@ -150,73 +150,73 @@ namespace { mpfr_div(tempfb, tempfnum, tempfden, GMP_RNDN); if (mpfr_asprintf(&buf, "%.*RNf", precision, tempfb) < 0) - throw_(amount_error, - _("Cannot output amount to a floating-point representation")); - + throw_(amount_error, + _("Cannot output amount to a floating-point representation")); + DEBUG("amount.convert", "mpfr_print = " << buf - << " (precision " << precision - << ", zeros_prec " << zeros_prec << ")"); + << " (precision " << precision + << ", zeros_prec " << zeros_prec << ")"); if (zeros_prec >= 0) { - string::size_type index = std::strlen(buf); - string::size_type point = 0; - for (string::size_type i = 0; i < index; i++) { - if (buf[i] == '.') { - point = i; - break; - } - } - if (point > 0) { - while (--index >= (point + 1 + zeros_prec) && buf[index] == '0') - buf[index] = '\0'; - if (index >= (point + zeros_prec) && buf[index] == '.') - buf[index] = '\0'; - } + string::size_type index = std::strlen(buf); + string::size_type point = 0; + for (string::size_type i = 0; i < index; i++) { + if (buf[i] == '.') { + point = i; + break; + } + } + if (point > 0) { + while (--index >= (point + 1 + zeros_prec) && buf[index] == '0') + buf[index] = '\0'; + if (index >= (point + zeros_prec) && buf[index] == '.') + buf[index] = '\0'; + } } if (comm) { - int integer_digits = 0; - if (comm && comm->has_flags(COMMODITY_STYLE_THOUSANDS)) { - // Count the number of integer digits - for (const char * p = buf; *p; p++) { - if (*p == '.') - break; - else if (*p != '-') - integer_digits++; - } - } - - for (const char * p = buf; *p; p++) { - if (*p == '.') { - if (commodity_t::decimal_comma_by_default || - (comm && comm->has_flags(COMMODITY_STYLE_DECIMAL_COMMA))) - out << ','; - else - out << *p; - assert(integer_digits <= 3); - } - else if (*p == '-') { - out << *p; - } - else { - out << *p; - - if (integer_digits > 3 && --integer_digits % 3 == 0) { - if (commodity_t::decimal_comma_by_default || - (comm && comm->has_flags(COMMODITY_STYLE_DECIMAL_COMMA))) - out << '.'; - else - out << ','; - } - } - } + int integer_digits = 0; + if (comm && comm->has_flags(COMMODITY_STYLE_THOUSANDS)) { + // Count the number of integer digits + for (const char * p = buf; *p; p++) { + if (*p == '.') + break; + else if (*p != '-') + integer_digits++; + } + } + + for (const char * p = buf; *p; p++) { + if (*p == '.') { + if (commodity_t::decimal_comma_by_default || + (comm && comm->has_flags(COMMODITY_STYLE_DECIMAL_COMMA))) + out << ','; + else + out << *p; + assert(integer_digits <= 3); + } + else if (*p == '-') { + out << *p; + } + else { + out << *p; + + if (integer_digits > 3 && --integer_digits % 3 == 0) { + if (commodity_t::decimal_comma_by_default || + (comm && comm->has_flags(COMMODITY_STYLE_DECIMAL_COMMA))) + out << '.'; + else + out << ','; + } + } + } } else { - out << buf; + out << buf; } } catch (...) { if (buf != NULL) - mpfr_free_str(buf); + mpfr_free_str(buf); throw; } if (buf != NULL) @@ -288,7 +288,7 @@ void amount_t::_copy(const amount_t& amt) } else { quantity = amt.quantity; DEBUG("amounts.refs", - quantity << " refc++, now " << (quantity->refc + 1)); + quantity << " refc++, now " << (quantity->refc + 1)); quantity->refc++; } } @@ -391,8 +391,8 @@ int amount_t::compare(const amount_t& amt) const if (has_commodity() && amt.has_commodity() && commodity() != amt.commodity()) throw_(amount_error, - _("Cannot compare amounts with different commodities: %1 and %2") - << commodity().symbol() << amt.commodity().symbol()); + _("Cannot compare amounts with different commodities: %1 and %2") + << commodity().symbol() << amt.commodity().symbol()); return mpq_cmp(MP(quantity), MP(amt.quantity)); } @@ -426,9 +426,9 @@ amount_t& amount_t::operator+=(const amount_t& amt) if (has_commodity() && amt.has_commodity() && commodity() != amt.commodity()) throw_(amount_error, - _("Adding amounts with different commodities: %1 != %2") - << (has_commodity() ? commodity().symbol() : _("NONE")) - << (amt.has_commodity() ? amt.commodity().symbol() : _("NONE"))); + _("Adding amounts with different commodities: %1 != %2") + << (has_commodity() ? commodity().symbol() : _("NONE")) + << (amt.has_commodity() ? amt.commodity().symbol() : _("NONE"))); _dup(); @@ -457,9 +457,9 @@ amount_t& amount_t::operator-=(const amount_t& amt) if (has_commodity() && amt.has_commodity() && commodity() != amt.commodity()) throw_(amount_error, - _("Subtracting amounts with different commodities: %1 != %2") - << (has_commodity() ? commodity().symbol() : _("NONE")) - << (amt.has_commodity() ? amt.commodity().symbol() : _("NONE"))); + _("Subtracting amounts with different commodities: %1 != %2") + << (has_commodity() ? commodity().symbol() : _("NONE")) + << (amt.has_commodity() ? amt.commodity().symbol() : _("NONE"))); _dup(); @@ -527,7 +527,7 @@ amount_t& amount_t::operator/=(const amount_t& amt) mpq_div(MP(quantity), MP(quantity), MP(amt.quantity)); quantity->prec = static_cast<precision_t>(quantity->prec + amt.quantity->prec + - extend_by_digits); + extend_by_digits); if (! has_commodity()) commodity_ = amt.commodity_; @@ -550,7 +550,7 @@ amount_t::precision_t amount_t::precision() const { if (! quantity) throw_(amount_error, - _("Cannot determine precision of an uninitialized amount")); + _("Cannot determine precision of an uninitialized amount")); return quantity->prec; } @@ -559,7 +559,7 @@ bool amount_t::keep_precision() const { if (! quantity) throw_(amount_error, - _("Cannot determine if precision of an uninitialized amount is kept")); + _("Cannot determine if precision of an uninitialized amount is kept")); return quantity->has_flags(BIGINT_KEEP_PREC); } @@ -568,7 +568,7 @@ void amount_t::set_keep_precision(const bool keep) const { if (! quantity) throw_(amount_error, - _("Cannot set whether to keep the precision of an uninitialized amount")); + _("Cannot set whether to keep the precision of an uninitialized amount")); if (keep) quantity->add_flags(BIGINT_KEEP_PREC); @@ -580,7 +580,7 @@ amount_t::precision_t amount_t::display_precision() const { if (! quantity) throw_(amount_error, - _("Cannot determine display precision of an uninitialized amount")); + _("Cannot determine display precision of an uninitialized amount")); commodity_t& comm(commodity()); @@ -632,7 +632,7 @@ void amount_t::in_place_truncate() _dup(); DEBUG("amount.truncate", - "Truncating " << *this << " to precision " << display_precision()); + "Truncating " << *this << " to precision " << display_precision()); std::ostringstream out; stream_out_mpq(out, MP(quantity), display_precision()); @@ -704,9 +704,9 @@ void amount_t::in_place_unreduce() if (! quantity) throw_(amount_error, _("Cannot unreduce an uninitialized amount")); - amount_t temp = *this; - commodity_t * comm = commodity_; - bool shifted = false; + amount_t temp = *this; + commodity_t * comm = commodity_; + bool shifted = false; while (comm && comm->larger()) { amount_t next_temp = temp / comm->larger()->number(); @@ -725,57 +725,57 @@ void amount_t::in_place_unreduce() optional<amount_t> amount_t::value(const optional<datetime_t>& moment, - const optional<commodity_t&>& in_terms_of) const + const optional<commodity_t&>& in_terms_of) const { if (quantity) { #if defined(DEBUG_ON) DEBUG("commodity.prices.find", - "amount_t::value of " << commodity().symbol()); + "amount_t::value of " << commodity().symbol()); if (moment) DEBUG("commodity.prices.find", - "amount_t::value: moment = " << *moment); + "amount_t::value: moment = " << *moment); if (in_terms_of) DEBUG("commodity.prices.find", - "amount_t::value: in_terms_of = " << in_terms_of->symbol()); + "amount_t::value: in_terms_of = " << in_terms_of->symbol()); #endif if (has_commodity() && - (in_terms_of || ! commodity().has_flags(COMMODITY_PRIMARY))) { + (in_terms_of || ! commodity().has_flags(COMMODITY_PRIMARY))) { optional<price_point_t> point; optional<commodity_t&> comm(in_terms_of); if (comm && commodity().referent() == comm->referent()) { - return *this; + return *this; } else if (has_annotation() && annotation().price) { - if (annotation().has_flags(ANNOTATION_PRICE_FIXATED)) { - point = price_point_t(); - point->price = *annotation().price; - } - else if (! in_terms_of) { - comm = annotation().price->commodity(); - } + if (annotation().has_flags(ANNOTATION_PRICE_FIXATED)) { + point = price_point_t(); + point->price = *annotation().price; + } + else if (! in_terms_of) { + comm = annotation().price->commodity(); + } } if (! point) { - point = commodity().find_price(comm, moment); - // Whether a price was found or not, check whether we should attempt - // to download a price from the Internet. This is done if (a) no - // price was found, or (b) the price is "stale" according to the - // setting of --price-exp. - if (point) - point = commodity().check_for_updated_price(point, moment, comm); + point = commodity().find_price(comm, moment); + // Whether a price was found or not, check whether we should attempt + // to download a price from the Internet. This is done if (a) no + // price was found, or (b) the price is "stale" according to the + // setting of --price-exp. + if (point) + point = commodity().check_for_updated_price(point, moment, comm); } if (point) { - amount_t price(point->price); - price.multiply(*this, true); - price.in_place_round(); - return price; + amount_t price(point->price); + price.multiply(*this, true); + price.in_place_round(); + return price; } } } else { throw_(amount_error, - _("Cannot determine value of an uninitialized amount")); + _("Cannot determine value of an uninitialized amount")); } return none; } @@ -813,7 +813,7 @@ bool amount_t::is_zero() const return true; } else if (mpz_cmp(mpq_numref(MP(quantity)), - mpq_denref(MP(quantity))) > 0) { + mpq_denref(MP(quantity))) > 0) { DEBUG("amount.is_zero", "Numerator is larger than the denominator"); return false; } @@ -825,9 +825,9 @@ bool amount_t::is_zero() const string output = out.str(); if (! output.empty()) { - for (const char * p = output.c_str(); *p; p++) - if (*p != '0' && *p != '.' && *p != '-') - return false; + for (const char * p = output.c_str(); *p; p++) + if (*p != '0' && *p != '.' && *p != '-') + return false; } return true; } @@ -863,7 +863,7 @@ bool amount_t::fits_in_long() const commodity_t& amount_t::commodity() const { return (has_commodity() ? - *commodity_ : *commodity_pool_t::current_pool->null_commodity); + *commodity_ : *commodity_pool_t::current_pool->null_commodity); } bool amount_t::has_commodity() const @@ -873,13 +873,13 @@ bool amount_t::has_commodity() const void amount_t::annotate(const annotation_t& details) { - commodity_t * this_base; + commodity_t * this_base; annotated_commodity_t * this_ann = NULL; if (! quantity) throw_(amount_error, _("Cannot annotate the commodity of an uninitialized amount")); else if (! has_commodity()) - return; // ignore attempt to annotate a "bare commodity + return; // ignore attempt to annotate a "bare commodity if (commodity().has_annotation()) { this_ann = &as_annotated_commodity(commodity()); @@ -890,7 +890,7 @@ void amount_t::annotate(const annotation_t& details) assert(this_base); DEBUG("amounts.commodities", "Annotating commodity for amount " - << *this << std::endl << details); + << *this << std::endl << details); if (commodity_t * ann_comm = this_base->pool().find_or_create(*this_base, details)) @@ -907,10 +907,10 @@ bool amount_t::has_annotation() const { if (! quantity) throw_(amount_error, - _("Cannot determine if an uninitialized amount's commodity is annotated")); + _("Cannot determine if an uninitialized amount's commodity is annotated")); assert(! has_commodity() || ! commodity().has_annotation() || - as_annotated_commodity(commodity()).details); + as_annotated_commodity(commodity()).details); return has_commodity() && commodity().has_annotation(); } @@ -918,11 +918,11 @@ annotation_t& amount_t::annotation() { if (! quantity) throw_(amount_error, - _("Cannot return commodity annotation details of an uninitialized amount")); + _("Cannot return commodity annotation details of an uninitialized amount")); if (! commodity().has_annotation()) throw_(amount_error, - _("Request for annotation details from an unannotated amount")); + _("Request for annotation details from an unannotated amount")); annotated_commodity_t& ann_comm(as_annotated_commodity(commodity())); return ann_comm.details; @@ -932,7 +932,7 @@ amount_t amount_t::strip_annotations(const keep_details_t& what_to_keep) const { if (! quantity) throw_(amount_error, - _("Cannot strip commodity annotations from an uninitialized amount")); + _("Cannot strip commodity annotations from an uninitialized amount")); if (! what_to_keep.keep_all(commodity())) { amount_t t(*this); @@ -949,7 +949,7 @@ namespace { char buf[256]; char c = peek_next_nonws(in); READ_INTO(in, buf, 255, c, - std::isdigit(c) || c == '-' || c == '.' || c == ','); + std::isdigit(c) || c == '-' || c == '.' || c == ','); string::size_type len = std::strlen(buf); while (len > 0 && ! std::isdigit(buf[len - 1])) { @@ -971,7 +971,7 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) string symbol; string quant; annotation_t details; - bool negative = false; + bool negative = false; commodity_t::flags_t comm_flags = COMMODITY_STYLE_DEFAULTS; @@ -988,28 +988,28 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) if (! in.eof() && ((n = static_cast<char>(in.peek())) != '\n')) { if (std::isspace(n)) - comm_flags |= COMMODITY_STYLE_SEPARATED; + comm_flags |= COMMODITY_STYLE_SEPARATED; commodity_t::parse_symbol(in, symbol); if (! symbol.empty()) - comm_flags |= COMMODITY_STYLE_SUFFIXED; + comm_flags |= COMMODITY_STYLE_SUFFIXED; if (! in.eof() && ((n = static_cast<char>(in.peek())) != '\n')) - details.parse(in); + details.parse(in); } } else { commodity_t::parse_symbol(in, symbol); if (! in.eof() && ((n = static_cast<char>(in.peek())) != '\n')) { if (std::isspace(static_cast<char>(in.peek()))) - comm_flags |= COMMODITY_STYLE_SEPARATED; + comm_flags |= COMMODITY_STYLE_SEPARATED; parse_quantity(in, quant); if (! quant.empty() && ! in.eof() && - ((n = static_cast<char>(in.peek())) != '\n')) - details.parse(in); + ((n = static_cast<char>(in.peek())) != '\n')) + details.parse(in); } } @@ -1059,7 +1059,7 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) if (details) commodity_ = - commodity_pool_t::current_pool->find_or_create(*commodity_, details); + commodity_pool_t::current_pool->find_or_create(*commodity_, details); } // Quickly scan through and verify the correctness of the amount's use of @@ -1083,59 +1083,59 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) if (ch == '.') { if (no_more_periods) - throw_(amount_error, _("Too many periods in amount")); + throw_(amount_error, _("Too many periods in amount")); if (decimal_comma_style) { - if (decimal_offset % 3 != 0) - throw_(amount_error, _("Incorrect use of thousand-mark period")); - comm_flags |= COMMODITY_STYLE_THOUSANDS; - no_more_commas = true; + if (decimal_offset % 3 != 0) + throw_(amount_error, _("Incorrect use of thousand-mark period")); + comm_flags |= COMMODITY_STYLE_THOUSANDS; + no_more_commas = true; } else { - if (last_comma != string::npos) { - decimal_comma_style = true; - if (decimal_offset % 3 != 0) - throw_(amount_error, _("Incorrect use of thousand-mark period")); - } else { - no_more_periods = true; - new_quantity->prec = decimal_offset; - decimal_offset = 0; - } + if (last_comma != string::npos) { + decimal_comma_style = true; + if (decimal_offset % 3 != 0) + throw_(amount_error, _("Incorrect use of thousand-mark period")); + } else { + no_more_periods = true; + new_quantity->prec = decimal_offset; + decimal_offset = 0; + } } if (last_period == string::npos) - last_period = string_index; + last_period = string_index; } else if (ch == ',') { if (no_more_commas) - throw_(amount_error, _("Too many commas in amount")); + throw_(amount_error, _("Too many commas in amount")); if (decimal_comma_style) { - if (last_period != string::npos) { - throw_(amount_error, _("Incorrect use of decimal comma")); - } else { - no_more_commas = true; - new_quantity->prec = decimal_offset; - decimal_offset = 0; - } + if (last_period != string::npos) { + throw_(amount_error, _("Incorrect use of decimal comma")); + } else { + no_more_commas = true; + new_quantity->prec = decimal_offset; + decimal_offset = 0; + } } else { - if (decimal_offset % 3 != 0) { - if (last_comma != string::npos || - last_period != string::npos) { - throw_(amount_error, _("Incorrect use of thousand-mark comma")); - } else { - decimal_comma_style = true; - no_more_commas = true; - new_quantity->prec = decimal_offset; - decimal_offset = 0; - } - } else { - comm_flags |= COMMODITY_STYLE_THOUSANDS; - no_more_periods = true; - } + if (decimal_offset % 3 != 0) { + if (last_comma != string::npos || + last_period != string::npos) { + throw_(amount_error, _("Incorrect use of thousand-mark comma")); + } else { + decimal_comma_style = true; + no_more_commas = true; + new_quantity->prec = decimal_offset; + decimal_offset = 0; + } + } else { + comm_flags |= COMMODITY_STYLE_THOUSANDS; + no_more_periods = true; + } } if (last_comma == string::npos) - last_comma = string_index; + last_comma = string_index; } else { decimal_offset++; @@ -1163,11 +1163,11 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) string::size_type len = quant.length(); scoped_array<char> buf(new char[len + 1]); const char * p = quant.c_str(); - char * t = buf.get(); + char * t = buf.get(); while (*p) { if (*p == ',' || *p == '.') - p++; + p++; *t++ = *p++; } *t = '\0'; @@ -1193,7 +1193,7 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) quantity = new_quantity.release(); if (! flags.has_flags(PARSE_NO_REDUCE)) - in_place_reduce(); // will not throw an exception + in_place_reduce(); // will not throw an exception VERIFY(valid()); @@ -1201,7 +1201,7 @@ bool amount_t::parse(std::istream& in, const parse_flags_t& flags) } void amount_t::parse_conversion(const string& larger_str, - const string& smaller_str) + const string& smaller_str) { amount_t larger, smaller; @@ -1213,7 +1213,7 @@ void amount_t::parse_conversion(const string& larger_str, if (larger.commodity()) { larger.commodity().set_smaller(smaller); larger.commodity().add_flags(smaller.commodity().flags() | - COMMODITY_NOMARKET); + COMMODITY_NOMARKET); } if (smaller.commodity()) smaller.commodity().set_larger(larger); @@ -1239,7 +1239,7 @@ void amount_t::print(std::ostream& _out, const uint_least8_t flags) const } stream_out_mpq(out, MP(quantity), display_precision(), - comm ? commodity().precision() : 0, comm); + comm ? commodity().precision() : 0, comm); if (comm.has_flags(COMMODITY_STYLE_SUFFIXED)) { if (comm.has_flags(COMMODITY_STYLE_SEPARATED)) @@ -1325,7 +1325,7 @@ void serialize(Archive& ar, MP_RAT& mpq, const unsigned int /* version */) template <class Archive> void serialize(Archive& ar, long unsigned int& integer, - const unsigned int /* version */) + const unsigned int /* version */) { ar & make_binary_object(&integer, sizeof(long unsigned int)); } @@ -1336,23 +1336,23 @@ void serialize(Archive& ar, long unsigned int& integer, BOOST_CLASS_EXPORT(ledger::annotated_commodity_t) template void boost::serialization::serialize(boost::archive::binary_iarchive&, - MP_INT&, const unsigned int); + MP_INT&, const unsigned int); template void boost::serialization::serialize(boost::archive::binary_oarchive&, - MP_INT&, const unsigned int); + MP_INT&, const unsigned int); template void boost::serialization::serialize(boost::archive::binary_iarchive&, - MP_RAT&, const unsigned int); + MP_RAT&, const unsigned int); template void boost::serialization::serialize(boost::archive::binary_oarchive&, - MP_RAT&, const unsigned int); + MP_RAT&, const unsigned int); template void boost::serialization::serialize(boost::archive::binary_iarchive&, - long unsigned int&, - const unsigned int); + long unsigned int&, + const unsigned int); template void boost::serialization::serialize(boost::archive::binary_oarchive&, - long unsigned int&, - const unsigned int); + long unsigned int&, + const unsigned int); template void ledger::amount_t::serialize(boost::archive::binary_iarchive&, - const unsigned int); + const unsigned int); template void ledger::amount_t::serialize(boost::archive::binary_oarchive&, - const unsigned int); + const unsigned int); #endif // HAVE_BOOST_SERIALIZATION diff --git a/src/amount.h b/src/amount.h index be4c5e45..929251d8 100644 --- a/src/amount.h +++ b/src/amount.h @@ -91,9 +91,9 @@ typedef basic_flags_t<parse_flags_enum_t, uint_least8_t> parse_flags_t; */ class amount_t : public ordered_field_operators<amount_t, - ordered_field_operators<amount_t, double, - ordered_field_operators<amount_t, unsigned long, - ordered_field_operators<amount_t, long> > > > + ordered_field_operators<amount_t, double, + ordered_field_operators<amount_t, unsigned long, + ordered_field_operators<amount_t, long> > > > { public: /** Ready the amount subsystem for use. @@ -125,8 +125,8 @@ protected: struct bigint_t; - bigint_t * quantity; - commodity_t * commodity_; + bigint_t * quantity; + commodity_t * commodity_; public: /** @name Constructors @@ -399,8 +399,8 @@ public: $100.00. */ optional<amount_t> - value(const optional<datetime_t>& moment = none, - const optional<commodity_t&>& in_terms_of = none) const; + value(const optional<datetime_t>& moment = none, + const optional<commodity_t&>& in_terms_of = none) const; amount_t price() const; @@ -646,16 +646,16 @@ public: parse(string, flags_t) also parses an amount from a string. */ bool parse(std::istream& in, - const parse_flags_t& flags = PARSE_DEFAULT); + const parse_flags_t& flags = PARSE_DEFAULT); bool parse(const string& str, - const parse_flags_t& flags = PARSE_DEFAULT) { + const parse_flags_t& flags = PARSE_DEFAULT) { std::istringstream stream(str); bool result = parse(stream, flags); return result; } static void parse_conversion(const string& larger_str, - const string& smaller_str); + const string& smaller_str); /*@}*/ @@ -683,7 +683,7 @@ public: #define AMOUNT_PRINT_ELIDE_COMMODITY_QUOTES 0x08 void print(std::ostream& out, - const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; + const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; /*@}*/ @@ -760,7 +760,7 @@ inline std::istream& operator>>(std::istream& in, amount_t& amt) { } void to_xml(std::ostream& out, const amount_t& amt, - bool commodity_details = false); + bool commodity_details = false); } // namespace ledger diff --git a/src/annotate.cc b/src/annotate.cc index e1e64ac2..08b73443 100644 --- a/src/annotate.cc +++ b/src/annotate.cc @@ -47,20 +47,20 @@ void annotation_t::parse(std::istream& in) char c = peek_next_nonws(in); if (c == '{') { if (price) - throw_(amount_error, _("Commodity specifies more than one price")); + throw_(amount_error, _("Commodity specifies more than one price")); in.get(c); c = peek_next_nonws(in); if (c == '=') { - in.get(c); - add_flags(ANNOTATION_PRICE_FIXATED); + in.get(c); + add_flags(ANNOTATION_PRICE_FIXATED); } READ_INTO(in, buf, 255, c, c != '}'); if (c == '}') - in.get(c); + in.get(c); else - throw_(amount_error, _("Commodity price lacks closing brace")); + throw_(amount_error, _("Commodity price lacks closing brace")); amount_t temp; temp.parse(buf, PARSE_NO_MIGRATE); @@ -70,27 +70,27 @@ void annotation_t::parse(std::istream& in) } else if (c == '[') { if (date) - throw_(amount_error, _("Commodity specifies more than one date")); + throw_(amount_error, _("Commodity specifies more than one date")); in.get(c); READ_INTO(in, buf, 255, c, c != ']'); if (c == ']') - in.get(c); + in.get(c); else - throw_(amount_error, _("Commodity date lacks closing bracket")); + throw_(amount_error, _("Commodity date lacks closing bracket")); date = parse_date(buf); } else if (c == '(') { if (tag) - throw_(amount_error, _("Commodity specifies more than one tag")); + throw_(amount_error, _("Commodity specifies more than one tag")); in.get(c); READ_INTO(in, buf, 255, c, c != ')'); if (c == ')') - in.get(c); + in.get(c); else - throw_(amount_error, _("Commodity tag lacks closing parenthesis")); + throw_(amount_error, _("Commodity tag lacks closing parenthesis")); tag = buf; } @@ -104,20 +104,20 @@ void annotation_t::parse(std::istream& in) #if defined(DEBUG_ON) if (SHOW_DEBUG("amounts.commodities") && *this) { DEBUG("amounts.commodities", - "Parsed commodity annotations: " << std::endl << *this); + "Parsed commodity annotations: " << std::endl << *this); } #endif } void annotation_t::print(std::ostream& out, bool keep_base, - bool no_computed_annotations) const + bool no_computed_annotations) const { if (price && (! no_computed_annotations || ! has_flags(ANNOTATION_PRICE_CALCULATED))) out << " {" - << (has_flags(ANNOTATION_PRICE_FIXATED) ? "=" : "") - << (keep_base ? *price : price->unreduced()) - << '}'; + << (has_flags(ANNOTATION_PRICE_FIXATED) ? "=" : "") + << (keep_base ? *price : price->unreduced()) + << '}'; if (date && (! no_computed_annotations || ! has_flags(ANNOTATION_DATE_CALCULATED))) @@ -131,7 +131,7 @@ void annotation_t::print(std::ostream& out, bool keep_base, bool keep_details_t::keep_all(const commodity_t& comm) const { return (! comm.has_annotation() || - (keep_price && keep_date && keep_tag && ! only_actuals)); + (keep_price && keep_date && keep_tag && ! only_actuals)); } bool keep_details_t::keep_any(const commodity_t& comm) const @@ -159,22 +159,22 @@ commodity_t& annotated_commodity_t::strip_annotations(const keep_details_t& what_to_keep) { DEBUG("commodity.annotated.strip", - "Reducing commodity " << *this << std::endl - << " keep price " << what_to_keep.keep_price << " " - << " keep date " << what_to_keep.keep_date << " " - << " keep tag " << what_to_keep.keep_tag); + "Reducing commodity " << *this << std::endl + << " keep price " << what_to_keep.keep_price << " " + << " keep date " << what_to_keep.keep_date << " " + << " keep tag " << what_to_keep.keep_tag); commodity_t * new_comm; - bool keep_price = (what_to_keep.keep_price && - (! what_to_keep.only_actuals || - ! details.has_flags(ANNOTATION_PRICE_CALCULATED))); - bool keep_date = (what_to_keep.keep_date && - (! what_to_keep.only_actuals || - ! details.has_flags(ANNOTATION_DATE_CALCULATED))); - bool keep_tag = (what_to_keep.keep_tag && - (! what_to_keep.only_actuals || - ! details.has_flags(ANNOTATION_TAG_CALCULATED))); + bool keep_price = (what_to_keep.keep_price && + (! what_to_keep.only_actuals || + ! details.has_flags(ANNOTATION_PRICE_CALCULATED))); + bool keep_date = (what_to_keep.keep_date && + (! what_to_keep.only_actuals || + ! details.has_flags(ANNOTATION_DATE_CALCULATED))); + bool keep_tag = (what_to_keep.keep_tag && + (! what_to_keep.only_actuals || + ! details.has_flags(ANNOTATION_TAG_CALCULATED))); if ((keep_price && details.price) || (keep_date && details.date) || @@ -182,8 +182,8 @@ annotated_commodity_t::strip_annotations(const keep_details_t& what_to_keep) { new_comm = pool().find_or_create (referent(), annotation_t(keep_price ? details.price : none, - keep_date ? details.date : none, - keep_tag ? details.tag : none)); + keep_date ? details.date : none, + keep_tag ? details.tag : none)); } else { new_comm = &referent(); } diff --git a/src/annotate.h b/src/annotate.h index 4f2f1b04..b590ca45 100644 --- a/src/annotate.h +++ b/src/annotate.h @@ -49,7 +49,7 @@ namespace ledger { struct annotation_t : public supports_flags<>, - public equality_comparable<annotation_t> + public equality_comparable<annotation_t> { #define ANNOTATION_PRICE_CALCULATED 0x01 #define ANNOTATION_PRICE_FIXATED 0x02 @@ -61,8 +61,8 @@ struct annotation_t : public supports_flags<>, optional<string> tag; explicit annotation_t(const optional<amount_t>& _price = none, - const optional<date_t>& _date = none, - const optional<string>& _tag = none) + const optional<date_t>& _date = none, + const optional<string>& _tag = none) : supports_flags<>(), price(_price), date(_date), tag(_tag) { TRACE_CTOR(annotation_t, "const optional<amount_t>& + date_t + string"); } @@ -81,14 +81,14 @@ struct annotation_t : public supports_flags<>, bool operator==(const annotation_t& rhs) const { return (price == rhs.price && - date == rhs.date && - tag == rhs.tag); + date == rhs.date && + tag == rhs.tag); } void parse(std::istream& in); void print(std::ostream& out, bool keep_base = false, - bool no_computed_annotations = false) const; + bool no_computed_annotations = false) const; bool valid() const { assert(*this); @@ -142,9 +142,9 @@ struct keep_details_t bool only_actuals; explicit keep_details_t(bool _keep_price = false, - bool _keep_date = false, - bool _keep_tag = false, - bool _only_actuals = false) + bool _keep_date = false, + bool _keep_tag = false, + bool _only_actuals = false) : keep_price(_keep_price), keep_date(_keep_date), keep_tag(_keep_tag), @@ -188,7 +188,7 @@ private: }; inline std::ostream& operator<<(std::ostream& out, - const annotation_t& details) { + const annotation_t& details) { details.print(out); return out; } @@ -196,8 +196,8 @@ inline std::ostream& operator<<(std::ostream& out, class annotated_commodity_t : public commodity_t, public equality_comparable<annotated_commodity_t, - equality_comparable2<annotated_commodity_t, commodity_t, - noncopyable> > + equality_comparable2<annotated_commodity_t, commodity_t, + noncopyable> > { protected: friend class commodity_pool_t; @@ -205,7 +205,7 @@ protected: commodity_t * ptr; explicit annotated_commodity_t(commodity_t * _ptr, - const annotation_t& _details) + const annotation_t& _details) : commodity_t(_ptr->parent_, _ptr->base), ptr(_ptr), details(_details) { TRACE_CTOR(annotated_commodity_t, "commodity_t *, annotation_t"); annotated = true; @@ -232,7 +232,7 @@ public: virtual commodity_t& strip_annotations(const keep_details_t& what_to_keep); virtual void write_annotations(std::ostream& out, - bool no_computed_annotations = false) const; + bool no_computed_annotations = false) const; #if defined(HAVE_BOOST_SERIALIZATION) private: diff --git a/src/archive.cc b/src/archive.cc index e7fc072e..28760512 100644 --- a/src/archive.cc +++ b/src/archive.cc @@ -59,9 +59,9 @@ BOOST_CLASS_EXPORT(ledger::auto_xact_t) BOOST_CLASS_EXPORT(ledger::period_xact_t) template void ledger::journal_t::serialize(boost::archive::binary_oarchive&, - const unsigned int); + const unsigned int); template void ledger::journal_t::serialize(boost::archive::binary_iarchive&, - const unsigned int); + const unsigned int); namespace ledger { namespace { @@ -113,7 +113,7 @@ bool archive_t::read_header() iarchive >> *this; DEBUG("archive.journal", - "Version number: " << std::hex << ARCHIVE_VERSION << std::dec); + "Version number: " << std::hex << ARCHIVE_VERSION << std::dec); DEBUG("archive.journal", "Number of sources: " << sources.size()); #if defined(DEBUG_ON) @@ -152,7 +152,7 @@ bool archive_t::should_load(const std::list<path>& data_files) if (data_files.size() != sources.size()) { DEBUG("archive.journal", "No, number of sources doesn't match: " - << data_files.size() << " != " << sources.size()); + << data_files.size() << " != " << sources.size()); return false; } @@ -171,23 +171,23 @@ bool archive_t::should_load(const std::list<path>& data_files) DEBUG("archive.journal", "Comparing against source file: " << *i.filename); if (*i.filename == p) { - if (! exists(*i.filename)) { - DEBUG("archive.journal", - "No, a referent source no longer exists: " << *i.filename); - return false; - } - - if (i.modtime != posix_time::from_time_t(last_write_time(p))) { - DEBUG("archive.journal", "No, a source's modtime has changed: " << p); - return false; - } - - if (i.size != file_size(p)) { - DEBUG("archive.journal", "No, a source's size has changed: " << p); - return false; - } - - found++; + if (! exists(*i.filename)) { + DEBUG("archive.journal", + "No, a referent source no longer exists: " << *i.filename); + return false; + } + + if (i.modtime != posix_time::from_time_t(last_write_time(p))) { + DEBUG("archive.journal", "No, a source's modtime has changed: " << p); + return false; + } + + if (i.size != file_size(p)) { + DEBUG("archive.journal", "No, a source's size has changed: " << p); + return false; + } + + found++; } } } @@ -225,7 +225,7 @@ bool archive_t::should_save(journal_t& journal) if (! exists(*i.filename)) { DEBUG("archive.journal", - "No, a source no longer exists: " << *i.filename); + "No, a source no longer exists: " << *i.filename); return false; } @@ -258,11 +258,11 @@ void archive_t::save(journal_t& journal) boost::archive::binary_oarchive oa(stream); DEBUG("archive.journal", "Creating archive with version " - << std::hex << ARCHIVE_VERSION << std::dec); + << std::hex << ARCHIVE_VERSION << std::dec); oa << *this; DEBUG("archive.journal", - "Archiving journal with " << sources.size() << " sources"); + "Archiving journal with " << sources.size() << " sources"); oa << journal; INFO_FINISH(archive); diff --git a/src/archive.h b/src/archive.h index e954cd3e..1ebf3496 100644 --- a/src/archive.h +++ b/src/archive.h @@ -48,7 +48,7 @@ namespace ledger { class archive_t { - path file; + path file; std::list<journal_t::fileinfo_t> sources; diff --git a/src/balance.cc b/src/balance.cc index a8bc649d..7ce9d994 100644 --- a/src/balance.cc +++ b/src/balance.cc @@ -35,7 +35,7 @@ #include "commodity.h" #include "annotate.h" #include "pool.h" -#include "unistring.h" // for justify() +#include "unistring.h" // for justify() namespace ledger { @@ -71,7 +71,7 @@ balance_t& balance_t::operator+=(const amount_t& amt) { if (amt.is_null()) throw_(balance_error, - _("Cannot add an uninitialized amount to a balance")); + _("Cannot add an uninitialized amount to a balance")); if (amt.is_realzero()) return *this; @@ -96,7 +96,7 @@ balance_t& balance_t::operator-=(const amount_t& amt) { if (amt.is_null()) throw_(balance_error, - _("Cannot subtract an uninitialized amount from a balance")); + _("Cannot subtract an uninitialized amount from a balance")); if (amt.is_realzero()) return *this; @@ -116,7 +116,7 @@ balance_t& balance_t::operator*=(const amount_t& amt) { if (amt.is_null()) throw_(balance_error, - _("Cannot multiply a balance by an uninitialized amount")); + _("Cannot multiply a balance by an uninitialized amount")); if (is_realzero()) { ; @@ -138,12 +138,12 @@ balance_t& balance_t::operator*=(const amount_t& amt) amounts.begin()->second *= amt; else throw_(balance_error, - _("Cannot multiply a balance with annotated commodities by a commoditized amount")); + _("Cannot multiply a balance with annotated commodities by a commoditized amount")); } else { assert(amounts.size() > 1); throw_(balance_error, - _("Cannot multiply a multi-commodity balance by a commoditized amount")); + _("Cannot multiply a multi-commodity balance by a commoditized amount")); } return *this; } @@ -152,7 +152,7 @@ balance_t& balance_t::operator/=(const amount_t& amt) { if (amt.is_null()) throw_(balance_error, - _("Cannot divide a balance by an uninitialized amount")); + _("Cannot divide a balance by an uninitialized amount")); if (is_realzero()) { ; @@ -174,19 +174,19 @@ balance_t& balance_t::operator/=(const amount_t& amt) amounts.begin()->second /= amt; else throw_(balance_error, - _("Cannot divide a balance with annotated commodities by a commoditized amount")); + _("Cannot divide a balance with annotated commodities by a commoditized amount")); } else { assert(amounts.size() > 1); throw_(balance_error, - _("Cannot divide a multi-commodity balance by a commoditized amount")); + _("Cannot divide a multi-commodity balance by a commoditized amount")); } return *this; } optional<balance_t> balance_t::value(const optional<datetime_t>& moment, - const optional<commodity_t&>& in_terms_of) const + const optional<commodity_t&>& in_terms_of) const { balance_t temp; bool resolved = false; @@ -223,11 +223,11 @@ balance_t::commodity_amount(const optional<const commodity_t&>& commodity) const // Try stripping annotations before giving an error. balance_t temp(strip_annotations(keep_details_t())); if (temp.amounts.size() == 1) - return temp.commodity_amount(commodity); + return temp.commodity_amount(commodity); throw_(amount_error, - _("Requested amount of a balance with multiple commodities: %1") - << temp); + _("Requested amount of a balance with multiple commodities: %1") + << temp); } } else if (amounts.size() > 0) { @@ -251,9 +251,9 @@ balance_t::strip_annotations(const keep_details_t& what_to_keep) const } void balance_t::print(std::ostream& out, - const int first_width, - const int latter_width, - const uint_least8_t flags) const + const int first_width, + const int latter_width, + const uint_least8_t flags) const { bool first = true; int lwidth = latter_width; @@ -269,7 +269,7 @@ void balance_t::print(std::ostream& out, sorted.push_back(&pair.second); std::stable_sort(sorted.begin(), sorted.end(), - commodity_t::compare_by_commodity()); + commodity_t::compare_by_commodity()); foreach (const amount_t * amount, sorted) { int width; @@ -284,7 +284,7 @@ void balance_t::print(std::ostream& out, std::ostringstream buf; amount->print(buf, flags); justify(out, buf.str(), width, flags & AMOUNT_PRINT_RIGHT_JUSTIFY, - flags & AMOUNT_PRINT_COLORIZE && amount->sign() < 0); + flags & AMOUNT_PRINT_COLORIZE && amount->sign() < 0); } if (first) { diff --git a/src/balance.h b/src/balance.h index 12d7bc02..ac22f3e7 100644 --- a/src/balance.h +++ b/src/balance.h @@ -65,19 +65,19 @@ DECLARE_EXCEPTION(balance_error, std::runtime_error); */ class balance_t : public equality_comparable<balance_t, - equality_comparable<balance_t, amount_t, - equality_comparable<balance_t, double, - equality_comparable<balance_t, unsigned long, - equality_comparable<balance_t, long, - additive<balance_t, - additive<balance_t, amount_t, - additive<balance_t, double, - additive<balance_t, unsigned long, - additive<balance_t, long, - multiplicative<balance_t, amount_t, - multiplicative<balance_t, double, - multiplicative<balance_t, unsigned long, - multiplicative<balance_t, long> > > > > > > > > > > > > > + equality_comparable<balance_t, amount_t, + equality_comparable<balance_t, double, + equality_comparable<balance_t, unsigned long, + equality_comparable<balance_t, long, + additive<balance_t, + additive<balance_t, amount_t, + additive<balance_t, double, + additive<balance_t, unsigned long, + additive<balance_t, long, + multiplicative<balance_t, amount_t, + multiplicative<balance_t, double, + multiplicative<balance_t, unsigned long, + multiplicative<balance_t, long> > > > > > > > > > > > > > { public: typedef std::map<commodity_t *, amount_t> amounts_map; @@ -111,7 +111,7 @@ public: TRACE_CTOR(balance_t, "const amount_t&"); if (amt.is_null()) throw_(balance_error, - _("Cannot initialize a balance from an uninitialized amount")); + _("Cannot initialize a balance from an uninitialized amount")); if (! amt.is_realzero()) amounts.insert(amounts_map::value_type(&amt.commodity(), amt)); } @@ -153,7 +153,7 @@ public: balance_t& operator=(const amount_t& amt) { if (amt.is_null()) throw_(balance_error, - _("Cannot assign an uninitialized amount to a balance")); + _("Cannot assign an uninitialized amount to a balance")); amounts.clear(); if (! amt.is_realzero()) @@ -187,17 +187,17 @@ public: bool operator==(const balance_t& bal) const { amounts_map::const_iterator i, j; for (i = amounts.begin(), j = bal.amounts.begin(); - i != amounts.end() && j != bal.amounts.end(); - i++, j++) { + i != amounts.end() && j != bal.amounts.end(); + i++, j++) { if (! (i->first == j->first && i->second == j->second)) - return false; + return false; } return i == amounts.end() && j == bal.amounts.end(); } bool operator==(const amount_t& amt) const { if (amt.is_null()) throw_(balance_error, - _("Cannot compare a balance to an uninitialized amount")); + _("Cannot compare a balance to an uninitialized amount")); if (amt.is_realzero()) return amounts.empty(); @@ -384,8 +384,8 @@ public: } optional<balance_t> - value(const optional<datetime_t>& moment = none, - const optional<commodity_t&>& in_terms_of = none) const; + value(const optional<datetime_t>& moment = none, + const optional<commodity_t&>& in_terms_of = none) const; balance_t price() const; @@ -417,7 +417,7 @@ public: foreach (const amounts_map::value_type& pair, amounts) if (pair.second.is_nonzero()) - return true; + return true; return false; } @@ -427,7 +427,7 @@ public: foreach (const amounts_map::value_type& pair, amounts) if (! pair.second.is_zero()) - return false; + return false; return true; } @@ -437,7 +437,7 @@ public: foreach (const amounts_map::value_type& pair, amounts) if (! pair.second.is_realzero()) - return false; + return false; return true; } @@ -468,7 +468,7 @@ public: return amounts.begin()->second; else throw_(balance_error, - _("Cannot convert a balance with multiple commodities to an amount")); + _("Cannot convert a balance with multiple commodities to an amount")); return amount_t(); } @@ -529,10 +529,10 @@ public: * relative amounts of those commodities. There is no option to * change this behavior. */ - void print(std::ostream& out, - const int first_width = -1, - const int latter_width = -1, - const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; + void print(std::ostream& out, + const int first_width = -1, + const int latter_width = -1, + const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; /** * Debugging methods. There are two methods defined to help with @@ -550,9 +550,9 @@ public: bool first = true; foreach (const amounts_map::value_type& pair, amounts) { if (first) - first = false; + first = false; else - out << ", "; + out << ", "; pair.second.print(out); } out << ")"; @@ -561,8 +561,8 @@ public: bool valid() const { foreach (const amounts_map::value_type& pair, amounts) if (! pair.second.valid()) { - DEBUG("ledger.validate", "balance_t: ! pair.second.valid()"); - return false; + DEBUG("ledger.validate", "balance_t: ! pair.second.valid()"); + return false; } return true; } diff --git a/src/chain.cc b/src/chain.cc index 9a74cdca..49e0e470 100644 --- a/src/chain.cc +++ b/src/chain.cc @@ -40,7 +40,7 @@ namespace ledger { post_handler_ptr chain_pre_post_handlers(post_handler_ptr base_handler, - report_t& report) + report_t& report) { post_handler_ptr handler(base_handler); @@ -52,11 +52,11 @@ post_handler_ptr chain_pre_post_handlers(post_handler_ptr base_handler, // This filter_posts will only pass through posts matching the `predicate'. if (report.HANDLED(limit_)) { DEBUG("report.predicate", - "Report predicate expression = " << report.HANDLER(limit_).str()); + "Report predicate expression = " << report.HANDLER(limit_).str()); handler.reset(new filter_posts - (handler, predicate_t(report.HANDLER(limit_).str(), - report.what_to_keep()), - report)); + (handler, predicate_t(report.HANDLER(limit_).str(), + report.what_to_keep()), + report)); } // budget_posts takes a set of posts from a data file and uses them to @@ -68,7 +68,7 @@ post_handler_ptr chain_pre_post_handlers(post_handler_ptr base_handler, if (report.budget_flags != BUDGET_NO_BUDGET) { budget_posts * budget_handler = new budget_posts(handler, - report.budget_flags); + report.budget_flags); budget_handler->add_period_xacts(report.session.journal->period_xacts); handler.reset(budget_handler); @@ -78,41 +78,41 @@ post_handler_ptr chain_pre_post_handlers(post_handler_ptr base_handler, // the filter get reported. if (report.HANDLED(limit_)) handler.reset(new filter_posts - (handler, predicate_t(report.HANDLER(limit_).str(), - report.what_to_keep()), - report)); + (handler, predicate_t(report.HANDLER(limit_).str(), + report.what_to_keep()), + report)); } else if (report.HANDLED(forecast_while_)) { forecast_posts * forecast_handler = new forecast_posts(handler, - predicate_t(report.HANDLER(forecast_while_).str(), - report.what_to_keep()), - report, - report.HANDLED(forecast_years_) ? - static_cast<std::size_t> - (report.HANDLER(forecast_years_).value.to_long()) : - 5UL); + predicate_t(report.HANDLER(forecast_while_).str(), + report.what_to_keep()), + report, + report.HANDLED(forecast_years_) ? + static_cast<std::size_t> + (report.HANDLER(forecast_years_).value.to_long()) : + 5UL); forecast_handler->add_period_xacts(report.session.journal->period_xacts); handler.reset(forecast_handler); // See above, under budget_posts. if (report.HANDLED(limit_)) handler.reset(new filter_posts - (handler, predicate_t(report.HANDLER(limit_).str(), - report.what_to_keep()), - report)); + (handler, predicate_t(report.HANDLER(limit_).str(), + report.what_to_keep()), + report)); } return handler; } post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, - report_t& report, - bool for_accounts_report) + report_t& report, + bool for_accounts_report) { - post_handler_ptr handler(base_handler); - predicate_t display_predicate; - predicate_t only_predicate; + post_handler_ptr handler(base_handler); + predicate_t display_predicate; + predicate_t only_predicate; display_filter_posts * display_filter = NULL; assert(report.HANDLED(amount_)); @@ -123,34 +123,34 @@ post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, // Make sure only forecast postings which match are allowed through if (report.HANDLED(forecast_while_)) { handler.reset(new filter_posts - (handler, predicate_t(report.HANDLER(forecast_while_).str(), - report.what_to_keep()), - report)); + (handler, predicate_t(report.HANDLER(forecast_while_).str(), + report.what_to_keep()), + report)); } // truncate_xacts cuts off a certain number of _xacts_ from being // displayed. It does not affect calculation. if (report.HANDLED(head_) || report.HANDLED(tail_)) handler.reset - (new truncate_xacts(handler, - report.HANDLED(head_) ? - report.HANDLER(head_).value.to_int() : 0, - report.HANDLED(tail_) ? - report.HANDLER(tail_).value.to_int() : 0)); + (new truncate_xacts(handler, + report.HANDLED(head_) ? + report.HANDLER(head_).value.to_int() : 0, + report.HANDLED(tail_) ? + report.HANDLER(tail_).value.to_int() : 0)); // changed_value_posts adds virtual posts to the list to account for changes // in market value of commodities, which otherwise would affect the running // total unpredictably. display_filter = new display_filter_posts(handler, report, - report.HANDLED(revalued) && - ! report.HANDLED(no_rounding)); + report.HANDLED(revalued) && + ! report.HANDLED(no_rounding)); handler.reset(display_filter); // filter_posts will only pass through posts matching the // `display_predicate'. if (report.HANDLED(display_)) { display_predicate = predicate_t(report.HANDLER(display_).str(), - report.what_to_keep()); + report.what_to_keep()); handler.reset(new filter_posts(handler, display_predicate, report)); } } @@ -161,21 +161,21 @@ post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, if (report.HANDLED(revalued) && (! for_accounts_report || report.HANDLED(unrealized))) handler.reset(new changed_value_posts(handler, report, for_accounts_report, - report.HANDLED(unrealized), - display_filter)); + report.HANDLED(unrealized), + display_filter)); // calc_posts computes the running total. When this appears will determine, // for example, whether filtered posts are included or excluded from the // running total. handler.reset(new calc_posts(handler, expr, (! for_accounts_report || - (report.HANDLED(revalued) && - report.HANDLED(unrealized))))); + (report.HANDLED(revalued) && + report.HANDLED(unrealized))))); // filter_posts will only pass through posts matching the // `secondary_predicate'. if (report.HANDLED(only_)) { only_predicate = predicate_t(report.HANDLER(only_).str(), - report.what_to_keep()); + report.what_to_keep()); handler.reset(new filter_posts(handler, only_predicate, report)); } @@ -184,13 +184,13 @@ post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, // value expression. if (report.HANDLED(sort_)) { if (report.HANDLED(sort_xacts_)) - handler.reset(new sort_xacts(handler, report.HANDLER(sort_).str())); + handler.reset(new sort_xacts(handler, report.HANDLER(sort_).str())); else - handler.reset(new sort_posts(handler, report.HANDLER(sort_).str())); + handler.reset(new sort_posts(handler, report.HANDLER(sort_).str())); } #if 0 else if (! report.HANDLED(period_) && - ! report.HANDLED(unsorted)) { + ! report.HANDLED(unsorted)) { handler.reset(new sort_posts(handler, "date")); } #endif @@ -199,8 +199,8 @@ post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, // with a subtotaled post for each commodity used. if (report.HANDLED(collapse)) handler.reset(new collapse_posts(handler, report, expr, - display_predicate, only_predicate, - report.HANDLED(collapse_if_zero))); + display_predicate, only_predicate, + report.HANDLED(collapse_if_zero))); // subtotal_posts combines all the posts it receives into one subtotal // xact, which has one post for each commodity in each account. @@ -225,37 +225,37 @@ post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, // weekly or monthly. if (report.HANDLED(period_)) { handler.reset(new interval_posts(handler, expr, - report.HANDLER(period_).str(), - report.HANDLED(exact), - report.HANDLED(empty))); + report.HANDLER(period_).str(), + report.HANDLED(exact), + report.HANDLED(empty))); handler.reset(new sort_posts(handler, "date")); } if (report.HANDLED(date_)) handler.reset(new transfer_details(handler, transfer_details::SET_DATE, - report.session.journal->master, - report.HANDLER(date_).str(), - report)); + report.session.journal->master, + report.HANDLER(date_).str(), + report)); if (report.HANDLED(account_)) { handler.reset(new transfer_details(handler, transfer_details::SET_ACCOUNT, - report.session.journal->master, - report.HANDLER(account_).str(), - report)); + report.session.journal->master, + report.HANDLER(account_).str(), + report)); } else if (report.HANDLED(pivot_)) { string pivot = report.HANDLER(pivot_).str(); pivot = string("\"") + pivot + ":\" + tag(\"" + pivot + "\")"; handler.reset(new transfer_details(handler, transfer_details::SET_ACCOUNT, - report.session.journal->master, pivot, - report)); + report.session.journal->master, pivot, + report)); } if (report.HANDLED(payee_)) handler.reset(new transfer_details(handler, transfer_details::SET_PAYEE, - report.session.journal->master, - report.HANDLER(payee_).str(), - report)); + report.session.journal->master, + report.HANDLER(payee_).str(), + report)); // related_posts will pass along all posts related to the post received. If // the `related_all' handler is on, then all the xact's posts are passed; diff --git a/src/chain.h b/src/chain.h index 1a50a077..7bd76712 100644 --- a/src/chain.h +++ b/src/chain.h @@ -94,17 +94,17 @@ class report_t; post_handler_ptr chain_pre_post_handlers(post_handler_ptr base_handler, - report_t& report); + report_t& report); post_handler_ptr chain_post_handlers(post_handler_ptr base_handler, - report_t& report, - bool for_accounts_report = false); + report_t& report, + bool for_accounts_report = false); inline post_handler_ptr chain_handlers(post_handler_ptr handler, - report_t& report, - bool for_accounts_report = false) { + report_t& report, + bool for_accounts_report = false) { handler = chain_post_handlers(handler, report, for_accounts_report); handler = chain_pre_post_handlers(handler, report); return handler; diff --git a/src/commodity.cc b/src/commodity.cc index 44d14c56..230113e8 100644 --- a/src/commodity.cc +++ b/src/commodity.cc @@ -41,13 +41,13 @@ namespace ledger { bool commodity_t::decimal_comma_by_default = false; void commodity_t::history_t::add_price(commodity_t& source, - const datetime_t& date, - const amount_t& price, - const bool reflexive) + const datetime_t& date, + const amount_t& price, + const bool reflexive) { DEBUG("commodity.prices.add", "add_price to " << source - << (reflexive ? " (secondary)" : " (primary)") - << " : " << date << ", " << price); + << (reflexive ? " (secondary)" : " (primary)") + << " : " << date << ", " << price); history_map::iterator i = prices.find(date); if (i != prices.end()) { @@ -64,7 +64,7 @@ void commodity_t::history_t::add_price(commodity_t& source, price.commodity().add_price(date, inverse, false); } else { DEBUG("commodity.prices.add", - "marking commodity " << source.symbol() << " as primary"); + "marking commodity " << source.symbol() << " as primary"); source.add_flags(COMMODITY_PRIMARY); } } @@ -81,15 +81,15 @@ bool commodity_t::history_t::remove_price(const datetime_t& date) void commodity_t::varied_history_t:: add_price(commodity_t& source, - const datetime_t& date, - const amount_t& price, - const bool reflexive) + const datetime_t& date, + const amount_t& price, + const bool reflexive) { optional<history_t&> hist = history(price.commodity()); if (! hist) { std::pair<history_by_commodity_map::iterator, bool> result = histories.insert(history_by_commodity_map::value_type - (&price.commodity(), history_t())); + (&price.commodity(), history_t())); assert(result.second); hist = (*result.first).second; @@ -100,7 +100,7 @@ void commodity_t::varied_history_t:: } bool commodity_t::varied_history_t::remove_price(const datetime_t& date, - commodity_t& comm) + commodity_t& comm) { DEBUG("commodity.prices.add", "varied_remove_price: " << date << ", " << comm); @@ -111,21 +111,21 @@ bool commodity_t::varied_history_t::remove_price(const datetime_t& date, optional<price_point_t> commodity_t::history_t::find_price(const optional<datetime_t>& moment, - const optional<datetime_t>& oldest + const optional<datetime_t>& oldest #if defined(DEBUG_ON) - , const int indent + , const int indent #endif - ) const + ) const { price_point_t point; bool found = false; #if defined(DEBUG_ON) -#define DEBUG_INDENT(cat, indent) \ - do { \ - if (SHOW_DEBUG(cat)) \ - for (int i = 0; i < indent; i++) \ - ledger::_log_buffer << " "; \ +#define DEBUG_INDENT(cat, indent) \ + do { \ + if (SHOW_DEBUG(cat)) \ + for (int i = 0; i < indent; i++) \ + ledger::_log_buffer << " "; \ } while (false) #else #define DEBUG_INDENT(cat, indent) @@ -171,15 +171,15 @@ commodity_t::history_t::find_price(const optional<datetime_t>& moment, } else { point.when = (*i).first; if (*moment < point.when) { - if (i != prices.begin()) { - --i; - point.when = (*i).first; - point.price = (*i).second; - found = true; - } + if (i != prices.begin()) { + --i; + point.when = (*i).first; + point.price = (*i).second; + found = true; + } } else { - point.price = (*i).second; - found = true; + point.price = (*i).second; + found = true; } DEBUG_INDENT("commodity.prices.find", indent); @@ -205,23 +205,23 @@ commodity_t::history_t::find_price(const optional<datetime_t>& moment, else { DEBUG_INDENT("commodity.prices.find", indent); DEBUG("commodity.prices.find", - "returning price: " << point.when << ", " << point.price); + "returning price: " << point.when << ", " << point.price); return point; } } optional<price_point_t> commodity_t::varied_history_t::find_price(const commodity_t& source, - const optional<commodity_t&>& commodity, - const optional<datetime_t>& moment, - const optional<datetime_t>& oldest + const optional<commodity_t&>& commodity, + const optional<datetime_t>& moment, + const optional<datetime_t>& oldest #if defined(DEBUG_ON) - , const int indent + , const int indent #endif - ) const + ) const { optional<price_point_t> point; - optional<datetime_t> limit = oldest; + optional<datetime_t> limit = oldest; #if defined(VERIFY_ON) if (commodity) { @@ -266,61 +266,61 @@ commodity_t::varied_history_t::find_price(const commodity_t& source, DEBUG_INDENT("commodity.prices.find", indent + 1); DEBUG("commodity.prices.find", - "searching for price via commodity '" << comm << "'"); + "searching for price via commodity '" << comm << "'"); point = hist.second.find_price(moment, limit #if defined(DEBUG_ON) - , indent + 2 + , indent + 2 #endif - ); + ); assert(! point || point->price.commodity() == comm); if (point) { optional<price_point_t> xlat; if (commodity && comm != *commodity) { - DEBUG_INDENT("commodity.prices.find", indent + 1); - DEBUG("commodity.prices.find", "looking for translation price"); + DEBUG_INDENT("commodity.prices.find", indent + 1); + DEBUG("commodity.prices.find", "looking for translation price"); - xlat = comm.find_price(commodity, moment, limit, true + xlat = comm.find_price(commodity, moment, limit, true #if defined(DEBUG_ON) - , indent + 2 + , indent + 2 #endif - ); - if (xlat) { - DEBUG_INDENT("commodity.prices.find", indent + 1); - DEBUG("commodity.prices.find", "found translated price " - << xlat->price << " from " << xlat->when); - - point->price = xlat->price * point->price; - if (xlat->when < point->when) { - point->when = xlat->when; - - DEBUG_INDENT("commodity.prices.find", indent + 1); - DEBUG("commodity.prices.find", - "adjusting date of result back to " << point->when); - } - } else { - DEBUG_INDENT("commodity.prices.find", indent + 1); - DEBUG("commodity.prices.find", "saw no translated price there"); - continue; - } + ); + if (xlat) { + DEBUG_INDENT("commodity.prices.find", indent + 1); + DEBUG("commodity.prices.find", "found translated price " + << xlat->price << " from " << xlat->when); + + point->price = xlat->price * point->price; + if (xlat->when < point->when) { + point->when = xlat->when; + + DEBUG_INDENT("commodity.prices.find", indent + 1); + DEBUG("commodity.prices.find", + "adjusting date of result back to " << point->when); + } + } else { + DEBUG_INDENT("commodity.prices.find", indent + 1); + DEBUG("commodity.prices.find", "saw no translated price there"); + continue; + } } assert(! commodity || point->price.commodity() == *commodity); DEBUG_INDENT("commodity.prices.find", indent + 1); DEBUG("commodity.prices.find", - "saw a price there: " << point->price << " from " << point->when); + "saw a price there: " << point->price << " from " << point->when); if (! limit || point->when > *limit) { - limit = point->when; - best = *point; - found = true; + limit = point->when; + best = *point; + found = true; - DEBUG_INDENT("commodity.prices.find", indent + 1); - DEBUG("commodity.prices.find", - "search limit adjusted to " << *limit); + DEBUG_INDENT("commodity.prices.find", indent + 1); + DEBUG("commodity.prices.find", + "search limit adjusted to " << *limit); } } else { DEBUG_INDENT("commodity.prices.find", indent + 1); @@ -331,7 +331,7 @@ commodity_t::varied_history_t::find_price(const commodity_t& source, if (found) { DEBUG_INDENT("commodity.prices.find", indent); DEBUG("commodity.download", - "found price " << best.price << " from " << best.when); + "found price " << best.price << " from " << best.when); return best; } return none; @@ -358,13 +358,13 @@ commodity_t::varied_history_t::history(const optional<commodity_t&>& commodity) optional<price_point_t> commodity_t::find_price(const optional<commodity_t&>& commodity, - const optional<datetime_t>& moment, - const optional<datetime_t>& oldest, - const bool nested + const optional<datetime_t>& moment, + const optional<datetime_t>& oldest, + const bool nested #if defined(DEBUG_ON) - , const int indent + , const int indent #endif - ) const + ) const { if (! has_flags(COMMODITY_WALKED) && base->varied_history) { optional<base_t::time_and_commodity_t> pair; @@ -375,26 +375,26 @@ commodity_t::find_price(const optional<commodity_t&>& commodity, if (! nested) { pair = base_t::time_and_commodity_t - (base_t::optional_time_pair_t(moment, oldest), - commodity ? &(*commodity) : NULL); + (base_t::optional_time_pair_t(moment, oldest), + commodity ? &(*commodity) : NULL); DEBUG_INDENT("commodity.prices.find", indent); DEBUG("commodity.prices.find", "looking for memoized args: " - << (moment ? format_datetime(*moment) : "NONE") << ", " - << (oldest ? format_datetime(*oldest) : "NONE") << ", " - << (commodity ? commodity->symbol() : "NONE")); + << (moment ? format_datetime(*moment) : "NONE") << ", " + << (oldest ? format_datetime(*oldest) : "NONE") << ", " + << (commodity ? commodity->symbol() : "NONE")); base_t::memoized_price_map::iterator i = base->price_map.find(*pair); if (i != base->price_map.end()) { - DEBUG_INDENT("commodity.prices.find", indent); - DEBUG("commodity.prices.find", "found! returning: " - << ((*i).second ? (*i).second->price : amount_t(0L))); + DEBUG_INDENT("commodity.prices.find", indent); + DEBUG("commodity.prices.find", "found! returning: " + << ((*i).second ? (*i).second->price : amount_t(0L))); #if defined(VERIFY_ON) - IF_VERIFY() { - found = true; - checkpoint = (*i).second; - } else + IF_VERIFY() { + found = true; + checkpoint = (*i).second; + } else #endif // defined(VERIFY_ON) - return (*i).second; + return (*i).second; } } @@ -406,11 +406,11 @@ commodity_t::find_price(const optional<commodity_t&>& commodity, DEBUG("commodity.prices.find", "manually finding price..."); point = base->varied_history->find_price(*this, commodity, - moment, oldest + moment, oldest #if defined(DEBUG_ON) - , indent + , indent #endif - ); + ); } catch (...) { const_cast<commodity_t&>(*this).drop_flags(COMMODITY_WALKED); @@ -427,19 +427,19 @@ commodity_t::find_price(const optional<commodity_t&>& commodity, if (! nested && pair) { if (base->price_map.size() > base_t::max_price_map_size) { - DEBUG_INDENT("commodity.prices.find", indent); - DEBUG("commodity.prices.find", - "price map has grown too large, clearing it by half"); + DEBUG_INDENT("commodity.prices.find", indent); + DEBUG("commodity.prices.find", + "price map has grown too large, clearing it by half"); - for (std::size_t i = 0; i < base_t::max_price_map_size >> 1; i++) - base->price_map.erase(base->price_map.begin()); + for (std::size_t i = 0; i < base_t::max_price_map_size >> 1; i++) + base->price_map.erase(base->price_map.begin()); } DEBUG_INDENT("commodity.prices.find", indent); DEBUG("commodity.prices.find", - "remembered: " << (point ? point->price : amount_t(0L))); + "remembered: " << (point ? point->price : amount_t(0L))); base->price_map.insert - (base_t::memoized_price_map::value_type(*pair, point)); + (base_t::memoized_price_map::value_type(*pair, point)); } return point; } @@ -448,8 +448,8 @@ commodity_t::find_price(const optional<commodity_t&>& commodity, optional<price_point_t> commodity_t::check_for_updated_price(const optional<price_point_t>& point, - const optional<datetime_t>& moment, - const optional<commodity_t&>& in_terms_of) + const optional<datetime_t>& moment, + const optional<commodity_t&>& in_terms_of) { if (pool().get_quotes && ! has_flags(COMMODITY_NOMARKET)) { bool exceeds_leeway = true; @@ -457,28 +457,28 @@ commodity_t::check_for_updated_price(const optional<price_point_t>& point, if (point) { time_duration_t::sec_type seconds_diff; if (moment) { - seconds_diff = (*moment - point->when).total_seconds(); - DEBUG("commodity.download", "moment = " << *moment); - DEBUG("commodity.download", "slip.moment = " << seconds_diff); + seconds_diff = (*moment - point->when).total_seconds(); + DEBUG("commodity.download", "moment = " << *moment); + DEBUG("commodity.download", "slip.moment = " << seconds_diff); } else { - seconds_diff = (TRUE_CURRENT_TIME() - point->when).total_seconds(); - DEBUG("commodity.download", "slip.now = " << seconds_diff); + seconds_diff = (TRUE_CURRENT_TIME() - point->when).total_seconds(); + DEBUG("commodity.download", "slip.now = " << seconds_diff); } DEBUG("commodity.download", "leeway = " << pool().quote_leeway); if (seconds_diff < pool().quote_leeway) - exceeds_leeway = false; + exceeds_leeway = false; } if (exceeds_leeway) { DEBUG("commodity.download", - "attempting to download a more current quote..."); + "attempting to download a more current quote..."); if (optional<price_point_t> quote = - pool().get_commodity_quote(*this, in_terms_of)) { - if (! in_terms_of || - (quote->price.has_commodity() && - quote->price.commodity() == *in_terms_of)) - return quote; + pool().get_commodity_quote(*this, in_terms_of)) { + if (! in_terms_of || + (quote->price.has_commodity() && + quote->price.commodity() == *in_terms_of)) + return quote; } } } @@ -568,43 +568,43 @@ void commodity_t::parse_symbol(std::istream& in, string& symbol) while (_p - buf < 255 && in.good() && ! in.eof() && c != '\n') { std::size_t bytes = 0; std::ptrdiff_t size = _p - buf; - unsigned char d = c; + unsigned char d = c; // Check for the start of a UTF-8 multi-byte encoded string if (d >= 192 && d <= 223 && size < 254) - bytes = 2; + bytes = 2; else if (d >= 224 && d <= 239 && size < 253) - bytes = 3; + bytes = 3; else if (d >= 240 && d <= 247 && size < 252) - bytes = 4; + bytes = 4; else if (d >= 248 && d <= 251 && size < 251) - bytes = 5; + bytes = 5; else if (d >= 252 && d <= 253 && size < 250) - bytes = 6; + bytes = 6; else if (d >= 254) // UTF-8 encoding error - break; - - if (bytes > 0) { // we're looking at a UTF-8 encoding - for (std::size_t i = 0; i < bytes; i++) { - in.get(c); - if (in.bad() || in.eof()) - throw_(amount_error, _("Invalid UTF-8 encoding for commodity name")); - *_p++ = c; - } + break; + + if (bytes > 0) { // we're looking at a UTF-8 encoding + for (std::size_t i = 0; i < bytes; i++) { + in.get(c); + if (in.bad() || in.eof()) + throw_(amount_error, _("Invalid UTF-8 encoding for commodity name")); + *_p++ = c; + } } else if (invalid_chars[static_cast<unsigned char>(c)]) { - break; + break; } else { - in.get(c); - if (in.eof()) - break; - if (c == '\\') { - in.get(c); - if (in.eof()) - throw_(amount_error, _("Backslash at end of commodity name")); - } - *_p++ = c; + in.get(c); + if (in.eof()) + break; + if (c == '\\') { + in.get(c); + if (in.eof()) + throw_(amount_error, _("Backslash at end of commodity name")); + } + *_p++ = c; } c = static_cast<char>(in.peek()); @@ -657,7 +657,7 @@ bool commodity_t::valid() const { if (symbol().empty() && this != pool().null_commodity) { DEBUG("ledger.validate", - "commodity_t: symbol().empty() && this != null_commodity"); + "commodity_t: symbol().empty() && this != null_commodity"); return false; } @@ -675,7 +675,7 @@ bool commodity_t::valid() const } bool commodity_t::compare_by_commodity::operator()(const amount_t * left, - const amount_t * right) const + const amount_t * right) const { commodity_t& leftcomm(left->commodity()); commodity_t& rightcomm(right->commodity()); @@ -707,14 +707,14 @@ bool commodity_t::compare_by_commodity::operator()(const amount_t * left, amount_t rightprice(*arightcomm.details.price); if (leftprice.commodity() == rightprice.commodity()) { - return (leftprice - rightprice).sign() < 0; + return (leftprice - rightprice).sign() < 0; } else { - // Since we have two different amounts, there's really no way - // to establish a true sorting order; we'll just do it based - // on the numerical values. - leftprice.clear_commodity(); - rightprice.clear_commodity(); - return (leftprice - rightprice).sign() < 0; + // Since we have two different amounts, there's really no way + // to establish a true sorting order; we'll just do it based + // on the numerical values. + leftprice.clear_commodity(); + rightprice.clear_commodity(); + return (leftprice - rightprice).sign() < 0; } } @@ -725,7 +725,7 @@ bool commodity_t::compare_by_commodity::operator()(const amount_t * left, if (aleftcomm.details.date && arightcomm.details.date) { gregorian::date_duration diff = - *aleftcomm.details.date - *arightcomm.details.date; + *aleftcomm.details.date - *arightcomm.details.date; return diff.is_negative(); } @@ -743,7 +743,7 @@ bool commodity_t::compare_by_commodity::operator()(const amount_t * left, } void to_xml(std::ostream& out, const commodity_t& comm, - bool commodity_details) + bool commodity_details) { push_xml x(out, "commodity", true); @@ -769,21 +769,21 @@ void to_xml(std::ostream& out, const commodity_t& comm, push_xml y(out, "varied-history"); foreach (const commodity_t::history_by_commodity_map::value_type& pair, - comm.varied_history()->histories) { - { - push_xml z(out, "symbol"); - out << y.guard(pair.first->symbol()); - } - { - push_xml z(out, "history"); - - foreach (const commodity_t::history_map::value_type& inner_pair, - pair.second.prices) { - push_xml w(out, "price-point"); - to_xml(out, inner_pair.first); - to_xml(out, inner_pair.second); - } - } + comm.varied_history()->histories) { + { + push_xml z(out, "symbol"); + out << y.guard(pair.first->symbol()); + } + { + push_xml z(out, "history"); + + foreach (const commodity_t::history_map::value_type& inner_pair, + pair.second.prices) { + push_xml w(out, "price-point"); + to_xml(out, inner_pair.first); + to_xml(out, inner_pair.second); + } + } } } } diff --git a/src/commodity.h b/src/commodity.h index 42f15f33..f2275d0e 100644 --- a/src/commodity.h +++ b/src/commodity.h @@ -92,19 +92,19 @@ public: { history_map prices; - void add_price(commodity_t& source, - const datetime_t& date, - const amount_t& price, - const bool reflexive = true); + void add_price(commodity_t& source, + const datetime_t& date, + const amount_t& price, + const bool reflexive = true); bool remove_price(const datetime_t& date); optional<price_point_t> find_price(const optional<datetime_t>& moment = none, - const optional<datetime_t>& oldest = none + const optional<datetime_t>& oldest = none #if defined(DEBUG_ON) - , const int indent = 0 + , const int indent = 0 #endif - ) const; + ) const; #if defined(HAVE_BOOST_SERIALIZATION) private: @@ -125,21 +125,21 @@ public: { history_by_commodity_map histories; - void add_price(commodity_t& source, - const datetime_t& date, - const amount_t& price, - const bool reflexive = true); + void add_price(commodity_t& source, + const datetime_t& date, + const amount_t& price, + const bool reflexive = true); bool remove_price(const datetime_t& date, commodity_t& commodity); optional<price_point_t> - find_price(const commodity_t& source, - const optional<commodity_t&>& commodity = none, - const optional<datetime_t>& moment = none, - const optional<datetime_t>& oldest = none + find_price(const commodity_t& source, + const optional<commodity_t&>& commodity = none, + const optional<datetime_t>& moment = none, + const optional<datetime_t>& oldest = none #if defined(DEBUG_ON) - , const int indent = 0 + , const int indent = 0 #endif - ) const; + ) const; optional<history_t&> history(const optional<commodity_t&>& commodity = none); @@ -169,26 +169,26 @@ protected: #define COMMODITY_STYLE_SEPARATED 0x002 #define COMMODITY_STYLE_DECIMAL_COMMA 0x004 #define COMMODITY_STYLE_THOUSANDS 0x008 -#define COMMODITY_NOMARKET 0x010 -#define COMMODITY_BUILTIN 0x020 -#define COMMODITY_WALKED 0x040 -#define COMMODITY_KNOWN 0x080 -#define COMMODITY_PRIMARY 0x100 +#define COMMODITY_NOMARKET 0x010 +#define COMMODITY_BUILTIN 0x020 +#define COMMODITY_WALKED 0x040 +#define COMMODITY_KNOWN 0x080 +#define COMMODITY_PRIMARY 0x100 - string symbol; + string symbol; amount_t::precision_t precision; - optional<string> name; - optional<string> note; + optional<string> name; + optional<string> note; optional<varied_history_t> varied_history; - optional<amount_t> smaller; - optional<amount_t> larger; + optional<amount_t> smaller; + optional<amount_t> larger; typedef std::pair<optional<datetime_t>, - optional<datetime_t> > optional_time_pair_t; + optional<datetime_t> > optional_time_pair_t; typedef std::pair<optional_time_pair_t, - commodity_t *> time_and_commodity_t; + commodity_t *> time_and_commodity_t; typedef std::map<time_and_commodity_t, - optional<price_point_t> > memoized_price_map; + optional<price_point_t> > memoized_price_map; static const std::size_t max_price_map_size = 16; mutable memoized_price_map price_map; @@ -198,10 +198,10 @@ protected: public: explicit base_t(const string& _symbol) : supports_flags<uint_least16_t> - (commodity_t::decimal_comma_by_default ? - static_cast<uint_least16_t>(COMMODITY_STYLE_DECIMAL_COMMA) : - static_cast<uint_least16_t>(COMMODITY_STYLE_DEFAULTS)), - symbol(_symbol), precision(0), searched(false) { + (commodity_t::decimal_comma_by_default ? + static_cast<uint_least16_t>(COMMODITY_STYLE_DECIMAL_COMMA) : + static_cast<uint_least16_t>(COMMODITY_STYLE_DEFAULTS)), + symbol(_symbol), precision(0), searched(false) { TRACE_CTOR(base_t, "const string&"); } virtual ~base_t() { @@ -237,10 +237,10 @@ protected: commodity_pool_t * parent_; optional<string> qualified_symbol; optional<string> mapping_key_; - bool annotated; + bool annotated; - explicit commodity_t(commodity_pool_t * _parent, - const shared_ptr<base_t>& _base) + explicit commodity_t(commodity_pool_t * _parent, + const shared_ptr<base_t>& _base) : delegates_flags<uint_least16_t>(*_base.get()), base(_base), parent_(_parent), annotated(false) { TRACE_CTOR(commodity_t, "commodity_pool_t *, shared_ptr<base_t>"); @@ -349,36 +349,36 @@ public: // base->varied_history object. void add_price(const datetime_t& date, const amount_t& price, - const bool reflexive = true) { + const bool reflexive = true) { if (! base->varied_history) base->varied_history = varied_history_t(); base->varied_history->add_price(*this, date, price, reflexive); DEBUG("commodity.prices.find", "Price added, clearing price_map"); - base->price_map.clear(); // a price was added, invalid the map + base->price_map.clear(); // a price was added, invalid the map } bool remove_price(const datetime_t& date, commodity_t& commodity) { if (base->varied_history) { base->varied_history->remove_price(date, commodity); DEBUG("commodity.prices.find", "Price removed, clearing price_map"); - base->price_map.clear(); // a price was added, invalid the map + base->price_map.clear(); // a price was added, invalid the map } return false; } optional<price_point_t> find_price(const optional<commodity_t&>& commodity = none, - const optional<datetime_t>& moment = none, - const optional<datetime_t>& oldest = none, - const bool nested = false + const optional<datetime_t>& moment = none, + const optional<datetime_t>& oldest = none, + const bool nested = false #if defined(DEBUG_ON) - , const int indent = 0 + , const int indent = 0 #endif - ) const; + ) const; optional<price_point_t> check_for_updated_price(const optional<price_point_t>& point, - const optional<datetime_t>& moment, - const optional<commodity_t&>& in_terms_of); + const optional<datetime_t>& moment, + const optional<commodity_t&>& in_terms_of); // Methods related to parsing, reading, writing, etc., the commodity // itself. @@ -432,7 +432,7 @@ inline std::ostream& operator<<(std::ostream& out, const commodity_t& comm) { } void to_xml(std::ostream& out, const commodity_t& comm, - bool commodity_details = false); + bool commodity_details = false); } // namespace ledger diff --git a/src/compare.cc b/src/compare.cc index f3c13cea..99e430a7 100644 --- a/src/compare.cc +++ b/src/compare.cc @@ -39,7 +39,7 @@ namespace ledger { void push_sort_value(std::list<sort_value_t>& sort_values, - expr_t::ptr_op_t node, scope_t& scope) + expr_t::ptr_op_t node, scope_t& scope) { if (node->kind == expr_t::op_t::O_CONS) { push_sort_value(sort_values, node->left(), scope); @@ -54,11 +54,11 @@ void push_sort_value(std::list<sort_value_t>& sort_values, sort_values.push_back(sort_value_t()); sort_values.back().inverted = inverted; - sort_values.back().value = expr_t(node).calc(scope).simplified(); + sort_values.back().value = expr_t(node).calc(scope).simplified(); if (sort_values.back().value.is_null()) throw_(calc_error, - _("Could not determine sorting value based an expression")); + _("Could not determine sorting value based an expression")); } } @@ -106,7 +106,7 @@ bool compare_items<account_t>::operator()(account_t * left, account_t * right) } DEBUG("value.sort", "Comparing accounts " << left->fullname() - << " <> " << right->fullname()); + << " <> " << right->fullname()); return sort_value_is_less_than(lxdata.sort_values, rxdata.sort_values); } diff --git a/src/compare.h b/src/compare.h index eeecd7cf..0ba9d424 100644 --- a/src/compare.h +++ b/src/compare.h @@ -50,7 +50,7 @@ class post_t; class account_t; void push_sort_value(std::list<sort_value_t>& sort_values, - expr_t::ptr_op_t node, scope_t& scope); + expr_t::ptr_op_t node, scope_t& scope); template <typename T> class compare_items @@ -84,14 +84,14 @@ bool compare_items<T>::operator()(T * left, T * right) { assert(left); assert(right); return sort_value_is_less_than(find_sort_values(left), - find_sort_values(right)); + find_sort_values(right)); } template <> bool compare_items<post_t>::operator()(post_t * left, post_t * right); template <> bool compare_items<account_t>::operator()(account_t * left, - account_t * right); + account_t * right); } // namespace ledger diff --git a/src/convert.cc b/src/convert.cc index adb82dd4..f33a6b2e 100644 --- a/src/convert.cc +++ b/src/convert.cc @@ -46,8 +46,8 @@ namespace ledger { value_t convert_command(call_scope_t& scope) { interactive_t args(scope, "s"); - report_t& report(find_scope<report_t>(scope)); - journal_t& journal(*report.session.journal.get()); + report_t& report(find_scope<report_t>(scope)); + journal_t& journal(*report.session.journal.get()); string bucket_name; if (report.HANDLED(account_)) @@ -69,16 +69,16 @@ value_t convert_command(call_scope_t& scope) xact_posts_iterator xact_iter(*xact); while ((post = xact_iter()) != NULL) { if (post->account == bucket) - break; + break; } if (post) { post_map_t::iterator i = post_map.find(post->amount); if (i == post_map.end()) { - std::list<post_t *> post_list; - post_list.push_back(post); - post_map.insert(post_map_t::value_type(post->amount, post_list)); + std::list<post_t *> post_list; + post_list.push_back(post); + post_map.insert(post_map_t::value_type(post->amount, post_list)); } else { - (*i).second.push_back(post); + (*i).second.push_back(post); } } } @@ -95,7 +95,7 @@ value_t convert_command(call_scope_t& scope) while (xact_t * xact = reader.read_xact(journal, bucket)) { if (report.HANDLED(invert)) { foreach (post_t * post, xact->posts) - post->amount.in_place_negate(); + post->amount.in_place_negate(); } bool matched = false; @@ -103,46 +103,46 @@ value_t convert_command(call_scope_t& scope) if (i != post_map.end()) { std::list<post_t *>& post_list((*i).second); foreach (post_t * post, post_list) { - if (xact->code && post->xact->code && - *xact->code == *post->xact->code) { - matched = true; - break; - } - else if (xact->actual_date() == post->actual_date()) { - matched = true; - break; - } + if (xact->code && post->xact->code && + *xact->code == *post->xact->code) { + matched = true; + break; + } + else if (xact->actual_date() == post->actual_date()) { + matched = true; + break; + } } } if (matched) { DEBUG("convert.csv", "Ignored xact with code: " << *xact->code); - checked_delete(xact); // ignore it + checked_delete(xact); // ignore it } else { if (xact->posts.front()->account == NULL) { - xacts_iterator xi; - xi.xacts_i = current_xacts.begin(); - xi.xacts_end = current_xacts.end(); - xi.xacts_uninitialized = false; - - // jww (2010-03-07): Bind this logic to an option: --auto-match - if (account_t * acct = - lookup_probable_account(xact->payee, xi, bucket).second) - xact->posts.front()->account = acct; - else - xact->posts.front()->account = unknown; + xacts_iterator xi; + xi.xacts_i = current_xacts.begin(); + xi.xacts_end = current_xacts.end(); + xi.xacts_uninitialized = false; + + // jww (2010-03-07): Bind this logic to an option: --auto-match + if (account_t * acct = + lookup_probable_account(xact->payee, xi, bucket).second) + xact->posts.front()->account = acct; + else + xact->posts.front()->account = unknown; } if (! journal.add_xact(xact)) { - checked_delete(xact); - throw_(std::runtime_error, - _("Failed to finalize derived transaction (check commodities)")); + checked_delete(xact); + throw_(std::runtime_error, + _("Failed to finalize derived transaction (check commodities)")); } else { - xact_posts_iterator xact_iter(*xact); - while (post_t * post = xact_iter()) - formatter(*post); + xact_posts_iterator xact_iter(*xact); + while (post_t * post = xact_iter()) + formatter(*post); } } } @@ -51,29 +51,29 @@ string csv_reader::read_field(std::istream& in) while (in.good() && ! in.eof()) { in.get(x); if (x == '\\') { - in.get(x); + in.get(x); } else if (x == '"' && in.peek() == '"') { - in.get(x); + in.get(x); } else if (x == c) { - if (x == '|') - in.unget(); - else if (in.peek() == ',') - in.get(c); - break; + if (x == '|') + in.unget(); + else if (in.peek() == ',') + in.get(c); + break; } if (x != '\0') - field += x; + field += x; } } else { while (in.good() && ! in.eof()) { in.get(c); if (c == ',') - break; + break; if (c != '\0') - field += c; + field += c; } } trim(field); @@ -144,7 +144,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) xact->set_state(item_t::CLEARED); - xact->pos = position_t(); + xact->pos = position_t(); xact->pos->pathname = "jww (2010-03-05): unknown"; xact->pos->beg_pos = in.tellg(); xact->pos->beg_line = 0; @@ -153,7 +153,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) post->xact = xact.get(); #if 0 - post->pos = position_t(); + post->pos = position_t(); post->pos->pathname = pathname; post->pos->beg_pos = line_beg_pos; post->pos->beg_line = linenum; @@ -163,7 +163,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) post->set_state(item_t::CLEARED); post->account = NULL; - int n = 0; + int n = 0; amount_t amt; string total; @@ -173,12 +173,12 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) switch (index[n]) { case FIELD_DATE: if (field.empty()) - goto restart; + goto restart; try { - xact->_date = parse_date(field); + xact->_date = parse_date(field); } catch (date_error&) { - goto restart; + goto restart; } break; @@ -188,21 +188,21 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) case FIELD_CODE: if (! field.empty()) - xact->code = field; + xact->code = field; break; case FIELD_PAYEE: { bool found = false; foreach (payee_mapping_t& value, journal.payee_mappings) { - DEBUG("csv.mappings", "Looking for payee mapping: " << value.first); - if (value.first.match(field)) { - xact->payee = value.second; - found = true; - break; - } + DEBUG("csv.mappings", "Looking for payee mapping: " << value.first); + if (value.first.match(field)) { + xact->payee = value.second; + found = true; + break; + } } if (! found) - xact->payee = field; + xact->payee = field; break; } @@ -210,8 +210,8 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) std::istringstream amount_str(field); amt.parse(amount_str, PARSE_NO_REDUCE); if (! amt.has_commodity() && - commodity_pool_t::current_pool->default_commodity) - amt.set_commodity(*commodity_pool_t::current_pool->default_commodity); + commodity_pool_t::current_pool->default_commodity) + amt.set_commodity(*commodity_pool_t::current_pool->default_commodity); post->amount = amt; break; } @@ -220,9 +220,9 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) std::istringstream amount_str(field); amt.parse(amount_str, PARSE_NO_REDUCE); if (! amt.has_commodity() && - commodity_pool_t::current_pool->default_commodity) - amt.set_commodity - (*commodity_pool_t::current_pool->default_commodity); + commodity_pool_t::current_pool->default_commodity) + amt.set_commodity + (*commodity_pool_t::current_pool->default_commodity); post->cost = amt; break; } @@ -237,7 +237,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) case FIELD_UNKNOWN: if (! names[n].empty() && ! field.empty()) - xact->set_tag(names[n], field); + xact->set_tag(names[n], field); break; } n++; @@ -245,7 +245,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) #if 0 xact->set_tag(_("Imported"), - string(format_date(CURRENT_DATE(), FMT_WRITTEN))); + string(format_date(CURRENT_DATE(), FMT_WRITTEN))); xact->set_tag(_("Original"), string(line)); xact->set_tag(_("SHA1"), string(sha1sum(line))); #endif @@ -268,7 +268,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) post->xact = xact.get(); #if 0 - post->pos = position_t(); + post->pos = position_t(); post->pos->pathname = pathname; post->pos->beg_pos = line_beg_pos; post->pos->beg_line = linenum; @@ -285,7 +285,7 @@ xact_t * csv_reader::read_xact(journal_t& journal, account_t * bucket) std::istringstream assigned_amount_str(total); amt.parse(assigned_amount_str, PARSE_NO_REDUCE); if (! amt.has_commodity() && - commodity_pool_t::current_pool->default_commodity) + commodity_pool_t::current_pool->default_commodity) amt.set_commodity(*commodity_pool_t::current_pool->default_commodity); post->assigned_amount = amt; } diff --git a/src/draft.cc b/src/draft.cc index d9f191b6..ba78fc42 100644 --- a/src/draft.cc +++ b/src/draft.cc @@ -57,45 +57,45 @@ void draft_t::xact_template_t::dump(std::ostream& out) const if (payee_mask.empty()) out << _("Payee mask: INVALID (template expression will cause an error)") - << std::endl; + << std::endl; else out << _("Payee mask: ") << payee_mask << std::endl; if (posts.empty()) { out << std::endl - << _("<Posting copied from last related transaction>") - << std::endl; + << _("<Posting copied from last related transaction>") + << std::endl; } else { bool has_only_from = true; bool has_only_to = true; foreach (const post_template_t& post, posts) { if (post.from) - has_only_to = false; + has_only_to = false; else - has_only_from = false; + has_only_from = false; } foreach (const post_template_t& post, posts) { straccstream accum; out << std::endl - << ACCUM(accum << _("[Posting \"%1\"]") - << (post.from ? _("from") : _("to"))) - << std::endl; + << ACCUM(accum << _("[Posting \"%1\"]") + << (post.from ? _("from") : _("to"))) + << std::endl; if (post.account_mask) - out << _(" Account mask: ") << *post.account_mask << std::endl; + out << _(" Account mask: ") << *post.account_mask << std::endl; else if (post.from) - out << _(" Account mask: <use last of last related accounts>") << std::endl; + out << _(" Account mask: <use last of last related accounts>") << std::endl; else - out << _(" Account mask: <use first of last related accounts>") << std::endl; + out << _(" Account mask: <use first of last related accounts>") << std::endl; if (post.amount) - out << _(" Amount: ") << *post.amount << std::endl; + out << _(" Amount: ") << *post.amount << std::endl; if (post.cost) - out << _(" Cost: ") << *post.cost_operator - << " " << *post.cost << std::endl; + out << _(" Cost: ") << *post.cost_operator + << " " << *post.cost << std::endl; } } } @@ -104,7 +104,7 @@ void draft_t::parse_args(const value_t& args) { regex date_mask(_("([0-9]+(?:[-/.][0-9]+)?(?:[-/.][0-9]+))?")); smatch what; - bool check_for_date = true; + bool check_for_date = true; tmpl = xact_template_t(); @@ -116,16 +116,16 @@ void draft_t::parse_args(const value_t& args) for (; begin != end; begin++) { if (check_for_date && - regex_match((*begin).to_string(), what, date_mask)) { + regex_match((*begin).to_string(), what, date_mask)) { tmpl->date = parse_date(what[0]); check_for_date = false; } else if (check_for_date && - bool(weekday = string_to_day_of_week(what[0]))) { + bool(weekday = string_to_day_of_week(what[0]))) { short dow = static_cast<short>(*weekday); date_t date = CURRENT_DATE() - date_duration(1); while (date.day_of_week() != dow) - date -= date_duration(1); + date -= date_duration(1); tmpl->date = date; check_for_date = false; } @@ -133,80 +133,80 @@ void draft_t::parse_args(const value_t& args) string arg = (*begin).to_string(); if (arg == "at") { - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - tmpl->payee_mask = (*++begin).to_string(); + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + tmpl->payee_mask = (*++begin).to_string(); } else if (arg == "to" || arg == "from") { - if (! post || post->account_mask) { - tmpl->posts.push_back(xact_template_t::post_template_t()); - post = &tmpl->posts.back(); - } - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - post->account_mask = mask_t((*++begin).to_string()); - post->from = arg == "from"; + if (! post || post->account_mask) { + tmpl->posts.push_back(xact_template_t::post_template_t()); + post = &tmpl->posts.back(); + } + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + post->account_mask = mask_t((*++begin).to_string()); + post->from = arg == "from"; } else if (arg == "on") { - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - tmpl->date = parse_date((*++begin).to_string()); - check_for_date = false; + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + tmpl->date = parse_date((*++begin).to_string()); + check_for_date = false; } else if (arg == "code") { - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - tmpl->code = (*++begin).to_string(); + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + tmpl->code = (*++begin).to_string(); } else if (arg == "note") { - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - tmpl->note = (*++begin).to_string(); + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + tmpl->note = (*++begin).to_string(); } else if (arg == "rest") { - ; // just ignore this argument + ; // just ignore this argument } else if (arg == "@" || arg == "@@") { - amount_t cost; - post->cost_operator = arg; - if (begin == end) - throw std::runtime_error(_("Invalid xact command arguments")); - arg = (*++begin).to_string(); - if (! cost.parse(arg, PARSE_SOFT_FAIL | PARSE_NO_MIGRATE)) - throw std::runtime_error(_("Invalid xact command arguments")); - post->cost = cost; + amount_t cost; + post->cost_operator = arg; + if (begin == end) + throw std::runtime_error(_("Invalid xact command arguments")); + arg = (*++begin).to_string(); + if (! cost.parse(arg, PARSE_SOFT_FAIL | PARSE_NO_MIGRATE)) + throw std::runtime_error(_("Invalid xact command arguments")); + post->cost = cost; } else { - // Without a preposition, it is either: - // - // A payee, if we have not seen one - // An account or an amount, if we have - // An account if an amount has just been seen - // An amount if an account has just been seen - - if (tmpl->payee_mask.empty()) { - tmpl->payee_mask = arg; - } else { - amount_t amt; - optional<mask_t> account; - - if (! amt.parse(arg, PARSE_SOFT_FAIL | PARSE_NO_MIGRATE)) - account = mask_t(arg); - - if (! post || - (account && post->account_mask) || - (! account && post->amount)) { - tmpl->posts.push_back(xact_template_t::post_template_t()); - post = &tmpl->posts.back(); - } - - if (account) { - post->account_mask = account; - } else { - post->amount = amt; - post = NULL; // an amount concludes this posting - } - } + // Without a preposition, it is either: + // + // A payee, if we have not seen one + // An account or an amount, if we have + // An account if an amount has just been seen + // An amount if an account has just been seen + + if (tmpl->payee_mask.empty()) { + tmpl->payee_mask = arg; + } else { + amount_t amt; + optional<mask_t> account; + + if (! amt.parse(arg, PARSE_SOFT_FAIL | PARSE_NO_MIGRATE)) + account = mask_t(arg); + + if (! post || + (account && post->account_mask) || + (! account && post->amount)) { + tmpl->posts.push_back(xact_template_t::post_template_t()); + post = &tmpl->posts.back(); + } + + if (account) { + post->account_mask = account; + } else { + post->amount = amt; + post = NULL; // an amount concludes this posting + } + } } } } @@ -217,14 +217,14 @@ void draft_t::parse_args(const value_t& args) // A single account at the end of the line is the "from" account if (tmpl->posts.size() > 1 && - tmpl->posts.back().account_mask && ! tmpl->posts.back().amount) + tmpl->posts.back().account_mask && ! tmpl->posts.back().amount) tmpl->posts.back().from = true; foreach (xact_template_t::post_template_t& post, tmpl->posts) { if (post.from) - has_only_to = false; + has_only_to = false; else - has_only_from = false; + has_only_from = false; } if (has_only_from) { @@ -252,17 +252,17 @@ xact_t * draft_t::insert(journal_t& journal) xacts_iterator xi(journal); if (xact_t * xact = lookup_probable_account(tmpl->payee_mask.str(), xi).first) { DEBUG("draft.xact", "Found payee by lookup: transaction on line " - << xact->pos->beg_line); + << xact->pos->beg_line); matching = xact; } else { for (xacts_list::reverse_iterator j = journal.xacts.rbegin(); - j != journal.xacts.rend(); - j++) { + j != journal.xacts.rend(); + j++) { if (tmpl->payee_mask.match((*j)->payee)) { - matching = *j; - DEBUG("draft.xact", - "Found payee match: transaction on line " << (*j)->pos->beg_line); - break; + matching = *j; + DEBUG("draft.xact", + "Found payee match: transaction on line " << (*j)->pos->beg_line); + break; } } } @@ -308,13 +308,13 @@ xact_t * draft_t::insert(journal_t& journal) DEBUG("draft.xact", "Template had no postings, copying from match"); foreach (post_t * post, matching->posts) { - added->add_post(new post_t(*post)); - added->posts.back()->set_state(item_t::UNCLEARED); + added->add_post(new post_t(*post)); + added->posts.back()->set_state(item_t::UNCLEARED); } } else { throw_(std::runtime_error, - _("No accounts, and no past transaction matching '%1'") - << tmpl->payee_mask); + _("No accounts, and no past transaction matching '%1'") + << tmpl->payee_mask); } } else { DEBUG("draft.xact", "Template had postings"); @@ -322,9 +322,9 @@ xact_t * draft_t::insert(journal_t& journal) bool any_post_has_amount = false; foreach (xact_template_t::post_template_t& post, tmpl->posts) { if (post.amount) { - DEBUG("draft.xact", " and at least one has an amount specified"); - any_post_has_amount = true; - break; + DEBUG("draft.xact", " and at least one has an amount specified"); + any_post_has_amount = true; + break; } } @@ -334,158 +334,158 @@ xact_t * draft_t::insert(journal_t& journal) commodity_t * found_commodity = NULL; if (matching) { - if (post.account_mask) { - DEBUG("draft.xact", - "Looking for matching posting based on account mask"); - - foreach (post_t * x, matching->posts) { - if (post.account_mask->match(x->account->fullname())) { - new_post.reset(new post_t(*x)); - DEBUG("draft.xact", - "Founding posting from line " << x->pos->beg_line); - break; - } - } - } else { - if (post.from) { - for (posts_list::reverse_iterator j = matching->posts.rbegin(); - j != matching->posts.rend(); - j++) { - if ((*j)->must_balance()) { - new_post.reset(new post_t(**j)); - DEBUG("draft.xact", - "Copied last real posting from matching"); - break; - } - } - } else { - for (posts_list::iterator j = matching->posts.begin(); - j != matching->posts.end(); - j++) { - if ((*j)->must_balance()) { - new_post.reset(new post_t(**j)); - DEBUG("draft.xact", - "Copied first real posting from matching"); - break; - } - } - } - } + if (post.account_mask) { + DEBUG("draft.xact", + "Looking for matching posting based on account mask"); + + foreach (post_t * x, matching->posts) { + if (post.account_mask->match(x->account->fullname())) { + new_post.reset(new post_t(*x)); + DEBUG("draft.xact", + "Founding posting from line " << x->pos->beg_line); + break; + } + } + } else { + if (post.from) { + for (posts_list::reverse_iterator j = matching->posts.rbegin(); + j != matching->posts.rend(); + j++) { + if ((*j)->must_balance()) { + new_post.reset(new post_t(**j)); + DEBUG("draft.xact", + "Copied last real posting from matching"); + break; + } + } + } else { + for (posts_list::iterator j = matching->posts.begin(); + j != matching->posts.end(); + j++) { + if ((*j)->must_balance()) { + new_post.reset(new post_t(**j)); + DEBUG("draft.xact", + "Copied first real posting from matching"); + break; + } + } + } + } } if (! new_post.get()) { - new_post.reset(new post_t); - DEBUG("draft.xact", "New posting was NULL, creating a blank one"); + new_post.reset(new post_t); + DEBUG("draft.xact", "New posting was NULL, creating a blank one"); } if (! new_post->account) { - DEBUG("draft.xact", "New posting still needs an account"); + DEBUG("draft.xact", "New posting still needs an account"); - if (post.account_mask) { - DEBUG("draft.xact", "The template has an account mask"); + if (post.account_mask) { + DEBUG("draft.xact", "The template has an account mask"); - account_t * acct = NULL; - if (! acct) { - acct = journal.find_account_re(post.account_mask->str()); + account_t * acct = NULL; + if (! acct) { + acct = journal.find_account_re(post.account_mask->str()); #if defined(DEBUG_ON) - if (acct) - DEBUG("draft.xact", "Found account as a regular expression"); + if (acct) + DEBUG("draft.xact", "Found account as a regular expression"); #endif - } - if (! acct) { - acct = journal.find_account(post.account_mask->str()); + } + if (! acct) { + acct = journal.find_account(post.account_mask->str()); #if defined(DEBUG_ON) - if (acct) - DEBUG("draft.xact", "Found (or created) account by name"); + if (acct) + DEBUG("draft.xact", "Found (or created) account by name"); #endif - } - - // Find out the default commodity to use by looking at the last - // commodity used in that account - for (xacts_list::reverse_iterator j = journal.xacts.rbegin(); - j != journal.xacts.rend(); - j++) { - foreach (post_t * x, (*j)->posts) { - if (x->account == acct && ! x->amount.is_null()) { - new_post.reset(new post_t(*x)); - DEBUG("draft.xact", - "Found account in journal postings, setting new posting"); - break; - } - } - } - - new_post->account = acct; - DEBUG("draft.xact", - "Set new posting's account to: " << acct->fullname()); - } else { - if (post.from) { - new_post->account = journal.find_account(_("Liabilities:Unknown")); - DEBUG("draft.xact", - "Set new posting's account to: Liabilities:Unknown"); - } else { - new_post->account = journal.find_account(_("Expenses:Unknown")); - DEBUG("draft.xact", - "Set new posting's account to: Expenses:Unknown"); - } - } + } + + // Find out the default commodity to use by looking at the last + // commodity used in that account + for (xacts_list::reverse_iterator j = journal.xacts.rbegin(); + j != journal.xacts.rend(); + j++) { + foreach (post_t * x, (*j)->posts) { + if (x->account == acct && ! x->amount.is_null()) { + new_post.reset(new post_t(*x)); + DEBUG("draft.xact", + "Found account in journal postings, setting new posting"); + break; + } + } + } + + new_post->account = acct; + DEBUG("draft.xact", + "Set new posting's account to: " << acct->fullname()); + } else { + if (post.from) { + new_post->account = journal.find_account(_("Liabilities:Unknown")); + DEBUG("draft.xact", + "Set new posting's account to: Liabilities:Unknown"); + } else { + new_post->account = journal.find_account(_("Expenses:Unknown")); + DEBUG("draft.xact", + "Set new posting's account to: Expenses:Unknown"); + } + } } assert(new_post->account); if (new_post.get() && ! new_post->amount.is_null()) { - found_commodity = &new_post->amount.commodity(); - - if (any_post_has_amount) { - new_post->amount = amount_t(); - DEBUG("draft.xact", "New posting has an amount, but we cleared it"); - } else { - any_post_has_amount = true; - DEBUG("draft.xact", "New posting has an amount, and we're using it"); - } + found_commodity = &new_post->amount.commodity(); + + if (any_post_has_amount) { + new_post->amount = amount_t(); + DEBUG("draft.xact", "New posting has an amount, but we cleared it"); + } else { + any_post_has_amount = true; + DEBUG("draft.xact", "New posting has an amount, and we're using it"); + } } if (post.amount) { - new_post->amount = *post.amount; - DEBUG("draft.xact", "Copied over posting amount"); + new_post->amount = *post.amount; + DEBUG("draft.xact", "Copied over posting amount"); - if (post.from) { - new_post->amount.in_place_negate(); - DEBUG("draft.xact", "Negated new posting amount"); - } + if (post.from) { + new_post->amount.in_place_negate(); + DEBUG("draft.xact", "Negated new posting amount"); + } } if (post.cost) { - if (post.cost->sign() < 0) - throw parse_error(_("A posting's cost may not be negative")); - - post.cost->in_place_unround(); - - if (*post.cost_operator == "@") { - // For the sole case where the cost might be uncommoditized, - // guarantee that the commodity of the cost after multiplication - // is the same as it was before. - commodity_t& cost_commodity(post.cost->commodity()); - *post.cost *= new_post->amount; - post.cost->set_commodity(cost_commodity); - } - else if (new_post->amount.sign() < 0) { - new_post->cost->in_place_negate(); - } - - new_post->cost = *post.cost; - DEBUG("draft.xact", "Copied over posting cost"); + if (post.cost->sign() < 0) + throw parse_error(_("A posting's cost may not be negative")); + + post.cost->in_place_unround(); + + if (*post.cost_operator == "@") { + // For the sole case where the cost might be uncommoditized, + // guarantee that the commodity of the cost after multiplication + // is the same as it was before. + commodity_t& cost_commodity(post.cost->commodity()); + *post.cost *= new_post->amount; + post.cost->set_commodity(cost_commodity); + } + else if (new_post->amount.sign() < 0) { + new_post->cost->in_place_negate(); + } + + new_post->cost = *post.cost; + DEBUG("draft.xact", "Copied over posting cost"); } if (found_commodity && - ! new_post->amount.is_null() && - ! new_post->amount.has_commodity()) { - new_post->amount.set_commodity(*found_commodity); - DEBUG("draft.xact", "Set posting amount commodity to: " - << new_post->amount.commodity()); - - new_post->amount = new_post->amount.rounded(); - DEBUG("draft.xact", - "Rounded posting amount to: " << new_post->amount); + ! new_post->amount.is_null() && + ! new_post->amount.has_commodity()) { + new_post->amount.set_commodity(*found_commodity); + DEBUG("draft.xact", "Set posting amount commodity to: " + << new_post->amount.commodity()); + + new_post->amount = new_post->amount.rounded(); + DEBUG("draft.xact", + "Rounded posting amount to: " << new_post->amount); } added->add_post(new_post.release()); @@ -498,7 +498,7 @@ xact_t * draft_t::insert(journal_t& journal) if (! journal.add_xact(added.get())) throw_(std::runtime_error, - _("Failed to finalize derived transaction (check commodities)")); + _("Failed to finalize derived transaction (check commodities)")); return added.release(); } diff --git a/src/emacs.cc b/src/emacs.cc index 3c8bb256..7abdfd7f 100644 --- a/src/emacs.cc +++ b/src/emacs.cc @@ -42,11 +42,11 @@ void format_emacs_posts::write_xact(xact_t& xact) { if (xact.pos) out << "\"" << xact.pos->pathname << "\" " - << xact.pos->beg_line << " "; + << xact.pos->beg_line << " "; else out << "\"\" " << -1 << " "; - tm when = gregorian::to_tm(xact.date()); + tm when = gregorian::to_tm(xact.date()); std::time_t date = std::mktime(&when); out << "(" << (date / 65536) << " " << (date % 65536) << " 0) "; @@ -86,7 +86,7 @@ void format_emacs_posts::operator()(post_t& post) out << " (" << -1 << " "; out << "\"" << post.reported_account()->fullname() << "\" \"" - << post.amount << "\""; + << post.amount << "\""; switch (post.state()) { case item_t::CLEARED: diff --git a/src/error.cc b/src/error.cc index 4b3a7786..39ac63ea 100644 --- a/src/error.cc +++ b/src/error.cc @@ -55,9 +55,9 @@ string file_context(const path& file, const std::size_t line) return buf.str(); } -string line_context(const string& line, - const string::size_type pos, - const string::size_type end_pos) +string line_context(const string& line, + const string::size_type pos, + const string::size_type end_pos) { std::ostringstream buf; buf << " " << line << "\n"; @@ -66,24 +66,24 @@ string line_context(const string& line, buf << " "; if (end_pos == 0) { for (string::size_type i = 0; i < pos; i += 1) - buf << " "; + buf << " "; buf << "^"; } else { for (string::size_type i = 0; i < end_pos; i += 1) { - if (i >= pos) - buf << "^"; - else - buf << " "; + if (i >= pos) + buf << "^"; + else + buf << " "; } } } return buf.str(); } -string source_context(const path& file, - const istream_pos_type pos, - const istream_pos_type end_pos, - const string& prefix) +string source_context(const path& file, + const istream_pos_type pos, + const istream_pos_type end_pos, + const string& prefix) { const std::streamoff len = end_pos - pos; if (! len || file == path("/dev/stdin")) diff --git a/src/error.h b/src/error.h index b8b011eb..b9960b03 100644 --- a/src/error.h +++ b/src/error.h @@ -56,9 +56,9 @@ inline void throw_func(const string& message) { throw T(message); } -#define throw_(cls, msg) \ - ((_desc_buffer << ACCUM(_desc_accum << msg)), \ - _desc_accum.clear(), \ +#define throw_(cls, msg) \ + ((_desc_buffer << ACCUM(_desc_accum << msg)), \ + _desc_accum.clear(), \ throw_func<cls>(_desc_buffer.str())) inline void warning_func(const string& message) { @@ -67,38 +67,38 @@ inline void warning_func(const string& message) { _desc_buffer.str(""); } -#define warning_(msg) \ - ((_desc_buffer << ACCUM(_desc_accum << msg)), \ - _desc_accum.clear(), \ +#define warning_(msg) \ + ((_desc_buffer << ACCUM(_desc_accum << msg)), \ + _desc_accum.clear(), \ warning_func(_desc_buffer.str())) -extern straccstream _ctxt_accum; +extern straccstream _ctxt_accum; extern std::ostringstream _ctxt_buffer; -#define add_error_context(msg) \ - ((long(_ctxt_buffer.tellp()) == 0) ? \ - ((_ctxt_buffer << ACCUM(_ctxt_accum << msg)), \ - _ctxt_accum.clear()) : \ - ((_ctxt_buffer << std::endl << ACCUM(_ctxt_accum << msg)), \ +#define add_error_context(msg) \ + ((long(_ctxt_buffer.tellp()) == 0) ? \ + ((_ctxt_buffer << ACCUM(_ctxt_accum << msg)), \ + _ctxt_accum.clear()) : \ + ((_ctxt_buffer << std::endl << ACCUM(_ctxt_accum << msg)), \ _ctxt_accum.clear())) string error_context(); string file_context(const path& file, std::size_t line); -string line_context(const string& line, - const string::size_type pos = 0, - const string::size_type end_pos = 0); - -string source_context(const path& file, - const istream_pos_type pos, - const istream_pos_type end_pos, - const string& prefix = ""); - -#define DECLARE_EXCEPTION(name, kind) \ - class name : public kind { \ - public: \ - explicit name(const string& why) throw() : kind(why) {} \ - virtual ~name() throw() {} \ +string line_context(const string& line, + const string::size_type pos = 0, + const string::size_type end_pos = 0); + +string source_context(const path& file, + const istream_pos_type pos, + const istream_pos_type end_pos, + const string& prefix = ""); + +#define DECLARE_EXCEPTION(name, kind) \ + class name : public kind { \ + public: \ + explicit name(const string& why) throw() : kind(why) {} \ + virtual ~name() throw() {} \ } } // namespace ledger diff --git a/src/expr.cc b/src/expr.cc index 62058e0b..defa5b79 100644 --- a/src/expr.cc +++ b/src/expr.cc @@ -37,7 +37,7 @@ namespace ledger { void expr_t::parse(std::istream& in, const parse_flags_t& flags, - const optional<string>& original_string) + const optional<string>& original_string) { parser_t parser; istream_pos_type start_pos = in.tellg(); @@ -78,36 +78,36 @@ value_t expr_t::real_calc(scope_t& scope) } catch (const std::exception& err) { if (locus) { - string current_context = error_context(); - - add_error_context(_("While evaluating value expression:")); - add_error_context(op_context(ptr, locus)); - - if (SHOW_INFO()) { - add_error_context(_("The value expression tree was:")); - std::ostringstream buf; - ptr->dump(buf, 0); - - std::istringstream in(buf.str()); - std::ostringstream out; - char linebuf[1024]; - bool first = true; - while (in.good() && ! in.eof()) { - in.getline(linebuf, 1023); - std::streamsize len = in.gcount(); - if (len > 0) { - if (first) - first = false; - else - out << '\n'; - out << " " << linebuf; - } - } - add_error_context(out.str()); - } - - if (! current_context.empty()) - add_error_context(current_context); + string current_context = error_context(); + + add_error_context(_("While evaluating value expression:")); + add_error_context(op_context(ptr, locus)); + + if (SHOW_INFO()) { + add_error_context(_("The value expression tree was:")); + std::ostringstream buf; + ptr->dump(buf, 0); + + std::istringstream in(buf.str()); + std::ostringstream out; + char linebuf[1024]; + bool first = true; + while (in.good() && ! in.eof()) { + in.getline(linebuf, 1023); + std::streamsize len = in.gcount(); + if (len > 0) { + if (first) + first = false; + else + out << '\n'; + out << " " << linebuf; + } + } + add_error_context(out.str()); + } + + if (! current_context.empty()) + add_error_context(current_context); } throw; } @@ -56,7 +56,7 @@ class expr_t : public expr_base_t<value_t> public: class op_t; - typedef intrusive_ptr<op_t> ptr_op_t; + typedef intrusive_ptr<op_t> ptr_op_t; typedef intrusive_ptr<const op_t> const_ptr_op_t; protected: @@ -112,13 +112,13 @@ public: return parse(stream, flags, str); } - virtual void parse(std::istream& in, - const parse_flags_t& flags = PARSE_DEFAULT, - const optional<string>& original_string = none); + virtual void parse(std::istream& in, + const parse_flags_t& flags = PARSE_DEFAULT, + const optional<string>& original_string = none); virtual void compile(scope_t& scope); virtual value_t real_calc(scope_t& scope); - bool is_constant() const; + bool is_constant() const; value_t& constant_value(); const value_t& constant_value() const; bool is_function() const; diff --git a/src/exprbase.h b/src/exprbase.h index 0c096ab4..7eee0398 100644 --- a/src/exprbase.h +++ b/src/exprbase.h @@ -78,7 +78,7 @@ public: protected: scope_t * context; string str; - bool compiled; + bool compiled; virtual result_type real_calc(scope_t& scope) = 0; @@ -117,7 +117,7 @@ public: return str; } void set_text(const string& txt) { - str = txt; + str = txt; compiled = false; } @@ -126,11 +126,11 @@ public: return parse(stream, flags, str); } virtual void parse(std::istream&, - const parse_flags_t& = PARSE_DEFAULT, - const optional<string>& original_string = none) { + const parse_flags_t& = PARSE_DEFAULT, + const optional<string>& original_string = none) { set_text(original_string ? *original_string : "<stream>"); } - + void mark_uncompiled() { compiled = false; } @@ -157,8 +157,8 @@ public: if (! compiled) { #if defined(DEBUG_ON) if (SHOW_DEBUG("expr.compile")) { - DEBUG("expr.compile", "Before compilation:"); - dump(*_log_stream); + DEBUG("expr.compile", "Before compilation:"); + dump(*_log_stream); } #endif // defined(DEBUG_ON) @@ -167,8 +167,8 @@ public: #if defined(DEBUG_ON) if (SHOW_DEBUG("expr.compile")) { - DEBUG("expr.compile", "After compilation:"); - dump(*_log_stream); + DEBUG("expr.compile", "After compilation:"); + dump(*_log_stream); } #endif // defined(DEBUG_ON) } @@ -249,7 +249,7 @@ private: template <typename ResultType> std::ostream& operator<<(std::ostream& out, - const expr_base_t<ResultType>& expr) { + const expr_base_t<ResultType>& expr) { expr.print(out); return out; } diff --git a/src/filters.cc b/src/filters.cc index 2c2a0d5a..819e3d97 100644 --- a/src/filters.cc +++ b/src/filters.cc @@ -76,7 +76,7 @@ void post_splitter::operator()(post_t& post) (*i).second.push_back(&post); } else { std::pair<value_to_posts_map::iterator, bool> inserted - = posts_map.insert(value_to_posts_map::value_type(result, posts_list())); + = posts_map.insert(value_to_posts_map::value_type(result, posts_list())); assert(inserted.second); (*inserted.first).second.push_back(&post); } @@ -84,7 +84,7 @@ void post_splitter::operator()(post_t& post) } pass_down_posts::pass_down_posts(post_handler_ptr handler, - posts_iterator& iter) + posts_iterator& iter) : item_handler<post_t>(handler) { TRACE_CTOR(pass_down_posts, "post_handler_ptr, posts_iterator"); @@ -129,16 +129,16 @@ void truncate_xacts::flush() bool print = false; if (head_count) { if (head_count > 0 && i < head_count) - print = true; + print = true; else if (head_count < 0 && i >= - head_count) - print = true; + print = true; } if (! print && tail_count) { if (tail_count > 0 && l - i <= tail_count) - print = true; + print = true; else if (tail_count < 0 && l - i > - tail_count) - print = true; + print = true; } if (print) @@ -173,7 +173,7 @@ void truncate_xacts::operator()(post_t& post) void sort_posts::post_accumulated_posts() { std::stable_sort(posts.begin(), posts.end(), - compare_items<post_t>(sort_order)); + compare_items<post_t>(sort_order)); foreach (post_t * post, posts) { post->xdata().drop_flags(POST_EXT_SORT_CALC); @@ -185,30 +185,30 @@ void sort_posts::post_accumulated_posts() namespace { void split_string(const string& str, const char ch, - std::list<string>& strings) + std::list<string>& strings) { const char * b = str.c_str(); for (const char * p = b; *p; p++) { if (*p == ch) { - strings.push_back(string(b, p - b)); - b = p + 1; + strings.push_back(string(b, p - b)); + b = p + 1; } } strings.push_back(string(b)); } account_t * create_temp_account_from_path(std::list<string>& account_names, - temporaries_t& temps, - account_t * master) + temporaries_t& temps, + account_t * master) { account_t * new_account = NULL; foreach (const string& name, account_names) { if (new_account) { - new_account = new_account->find_account(name); + new_account = new_account->find_account(name); } else { - new_account = master->find_account(name, false); - if (! new_account) - new_account = &temps.create_account(name, master); + new_account = master->find_account(name, false); + if (! new_account) + new_account = &temps.create_account(name, master); } } @@ -243,7 +243,7 @@ void anonymize_posts::render_commodity(amount_t& amt) if (amt.has_annotation()) amt.set_commodity (*commodity_pool_t::current_pool->find_or_create(buf.str(), - amt.annotation())); + amt.annotation())); else amt.set_commodity (*commodity_pool_t::current_pool->find_or_create(buf.str())); @@ -256,9 +256,9 @@ void anonymize_posts::render_commodity(amount_t& amt) void anonymize_posts::operator()(post_t& post) { - SHA1 sha; + SHA1 sha; uint_least32_t message_digest[5]; - bool copy_xact_details = false; + bool copy_xact_details = false; if (last_xact != post.xact) { temps.copy_xact(*post.xact); @@ -342,15 +342,15 @@ void calc_posts::operator()(post_t& post) namespace { void handle_value(const value_t& value, - account_t * account, - xact_t * xact, - temporaries_t& temps, - post_handler_ptr handler, - const date_t& date = date_t(), - const bool act_date_p = true, - const value_t& total = value_t(), - const bool direct_amount = false, - const bool mark_visited = false) + account_t * account, + xact_t * xact, + temporaries_t& temps, + post_handler_ptr handler, + const date_t& date = date_t(), + const bool act_date_p = true, + const value_t& total = value_t(), + const bool direct_amount = false, + const bool mark_visited = false) { post_t& post = temps.create_post(*xact, account); post.add_flags(ITEM_GENERATED); @@ -359,11 +359,11 @@ namespace { // such. This allows subtotal reports to show "(Account)" for accounts // that contain only virtual posts. if (account && account->has_xdata() && - account->xdata().has_flags(ACCOUNT_EXT_AUTO_VIRTUALIZE)) { + account->xdata().has_flags(ACCOUNT_EXT_AUTO_VIRTUALIZE)) { if (! account->xdata().has_flags(ACCOUNT_EXT_HAS_NON_VIRTUALS)) { - post.add_flags(POST_VIRTUAL); - if (! account->xdata().has_flags(ACCOUNT_EXT_HAS_UNB_VIRTUALS)) - post.add_flags(POST_MUST_BALANCE); + post.add_flags(POST_VIRTUAL); + if (! account->xdata().has_flags(ACCOUNT_EXT_HAS_UNB_VIRTUALS)) + post.add_flags(POST_MUST_BALANCE); } } @@ -371,9 +371,9 @@ namespace { if (is_valid(date)) { if (act_date_p) - xdata.date = date; + xdata.date = date; else - xdata.value_date = date; + xdata.value_date = date; } value_t temp(value); @@ -442,29 +442,29 @@ void collapse_posts::report_subtotal() date_t latest_date; foreach (post_t * post, component_posts) { - date_t date = post->date(); + date_t date = post->date(); date_t value_date = post->value_date(); if (! is_valid(earliest_date) || date < earliest_date) - earliest_date = date; + earliest_date = date; if (! is_valid(latest_date) || value_date > latest_date) - latest_date = value_date; + latest_date = value_date; } xact_t& xact = temps.create_xact(); - xact.payee = last_xact->payee; - xact._date = (is_valid(earliest_date) ? - earliest_date : last_xact->_date); + xact.payee = last_xact->payee; + xact._date = (is_valid(earliest_date) ? + earliest_date : last_xact->_date); DEBUG("filters.collapse", "Pseudo-xact date = " << *xact._date); DEBUG("filters.collapse", "earliest date = " << earliest_date); DEBUG("filters.collapse", "latest date = " << latest_date); handle_value(/* value= */ subtotal, - /* account= */ &totals_account, - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ latest_date, - /* act_date_p= */ false); + /* account= */ &totals_account, + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ latest_date, + /* act_date_p= */ false); } component_posts.clear(); @@ -497,26 +497,26 @@ void related_posts::flush() if (posts.size() > 0) { foreach (post_t * post, posts) { if (post->xact) { - foreach (post_t * r_post, post->xact->posts) { - post_t::xdata_t& xdata(r_post->xdata()); - if (! xdata.has_flags(POST_EXT_HANDLED) && - (! xdata.has_flags(POST_EXT_RECEIVED) ? - ! r_post->has_flags(ITEM_GENERATED | POST_VIRTUAL) : - also_matching)) { - xdata.add_flags(POST_EXT_HANDLED); - item_handler<post_t>::operator()(*r_post); - } - } + foreach (post_t * r_post, post->xact->posts) { + post_t::xdata_t& xdata(r_post->xdata()); + if (! xdata.has_flags(POST_EXT_HANDLED) && + (! xdata.has_flags(POST_EXT_RECEIVED) ? + ! r_post->has_flags(ITEM_GENERATED | POST_VIRTUAL) : + also_matching)) { + xdata.add_flags(POST_EXT_HANDLED); + item_handler<post_t>::operator()(*r_post); + } + } } else { - // This code should only be reachable from the "output" - // command, since that is the only command which attempts to - // output auto or period xacts. - post_t::xdata_t& xdata(post->xdata()); - if (! xdata.has_flags(POST_EXT_HANDLED) && - ! post->has_flags(ITEM_GENERATED)) { - xdata.add_flags(POST_EXT_HANDLED); - item_handler<post_t>::operator()(*post); - } + // This code should only be reachable from the "output" + // command, since that is the only command which attempts to + // output auto or period xacts. + post_t::xdata_t& xdata(post->xdata()); + if (! xdata.has_flags(POST_EXT_HANDLED) && + ! post->has_flags(ITEM_GENERATED)) { + xdata.add_flags(POST_EXT_HANDLED); + item_handler<post_t>::operator()(*post); + } } } } @@ -525,15 +525,15 @@ void related_posts::flush() } display_filter_posts::display_filter_posts(post_handler_ptr handler, - report_t& _report, - bool _show_rounding) + report_t& _report, + bool _show_rounding) : item_handler<post_t>(handler), report(_report), show_rounding(_show_rounding), rounding_account(temps.create_account(_("<Rounding>"))), revalued_account(temps.create_account(_("<Revalued>"))) { TRACE_CTOR(display_filter_posts, - "post_handler_ptr, report_t&, account_t&, bool"); + "post_handler_ptr, report_t&, account_t&, bool"); display_amount_expr = report.HANDLER(display_amount_).expr; display_total_expr = report.HANDLER(display_total_).expr; @@ -548,7 +548,7 @@ bool display_filter_posts::output_rounding(post_t& post) new_display_total = display_total_expr.calc(bound_scope); DEBUG("filters.changed_value.rounding", - "rounding.new_display_total = " << new_display_total); + "rounding.new_display_total = " << new_display_total); } // Allow the posting to be displayed if: @@ -565,29 +565,29 @@ bool display_filter_posts::output_rounding(post_t& post) if (value_t repriced_amount = display_amount_expr.calc(bound_scope)) { if (! last_display_total.is_null()) { DEBUG("filters.changed_value.rounding", - "rounding.repriced_amount = " << repriced_amount); + "rounding.repriced_amount = " << repriced_amount); value_t precise_display_total(new_display_total.truncated() - - repriced_amount.truncated()); + repriced_amount.truncated()); DEBUG("filters.changed_value.rounding", - "rounding.precise_display_total = " << precise_display_total); + "rounding.precise_display_total = " << precise_display_total); DEBUG("filters.changed_value.rounding", - "rounding.last_display_total = " << last_display_total); + "rounding.last_display_total = " << last_display_total); if (value_t diff = precise_display_total - last_display_total) { - DEBUG("filters.changed_value.rounding", - "rounding.diff = " << diff); - - handle_value(/* value= */ diff, - /* account= */ &rounding_account, - /* xact= */ post.xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ date_t(), - /* act_date_p= */ true, - /* total= */ precise_display_total, - /* direct_amount= */ true); + DEBUG("filters.changed_value.rounding", + "rounding.diff = " << diff); + + handle_value(/* value= */ diff, + /* account= */ &rounding_account, + /* xact= */ post.xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ date_t(), + /* act_date_p= */ true, + /* total= */ precise_display_total, + /* direct_amount= */ true); } } if (show_rounding) @@ -605,23 +605,23 @@ void display_filter_posts::operator()(post_t& post) } changed_value_posts::changed_value_posts - (post_handler_ptr handler, - report_t& _report, - bool _for_accounts_report, - bool _show_unrealized, + (post_handler_ptr handler, + report_t& _report, + bool _for_accounts_report, + bool _show_unrealized, display_filter_posts * _display_filter) : item_handler<post_t>(handler), report(_report), for_accounts_report(_for_accounts_report), show_unrealized(_show_unrealized), last_post(NULL), revalued_account(_display_filter ? _display_filter->revalued_account : - temps.create_account(_("<Revalued>"))), + temps.create_account(_("<Revalued>"))), display_filter(_display_filter) { TRACE_CTOR(changed_value_posts, "post_handler_ptr, report_t&, bool"); - total_expr = (report.HANDLED(revalued_total_) ? - report.HANDLER(revalued_total_).expr : - report.HANDLER(display_total_).expr); + total_expr = (report.HANDLED(revalued_total_) ? + report.HANDLER(revalued_total_).expr : + report.HANDLER(display_total_).expr); display_total_expr = report.HANDLER(display_total_).expr; changed_values_only = report.HANDLED(revalued_only); @@ -671,51 +671,51 @@ void changed_value_posts::output_revaluation(post_t& post, const date_t& date) post.xdata().date = date_t(); DEBUG("filters.changed_value", - "output_revaluation(last_total) = " << last_total); + "output_revaluation(last_total) = " << last_total); DEBUG("filters.changed_value", - "output_revaluation(repriced_total) = " << repriced_total); + "output_revaluation(repriced_total) = " << repriced_total); if (! last_total.is_null()) { if (value_t diff = repriced_total - last_total) { DEBUG("filters.changed_value", "output_revaluation(strip(diff)) = " - << diff.strip_annotations(report.what_to_keep())); + << diff.strip_annotations(report.what_to_keep())); xact_t& xact = temps.create_xact(); xact.payee = _("Commodities revalued"); xact._date = is_valid(date) ? date : post.value_date(); if (! for_accounts_report) { - handle_value - (/* value= */ diff, - /* account= */ &revalued_account, - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ *xact._date, - /* act_date_p= */ true, - /* total= */ repriced_total); + handle_value + (/* value= */ diff, + /* account= */ &revalued_account, + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ *xact._date, + /* act_date_p= */ true, + /* total= */ repriced_total); } else if (show_unrealized) { - handle_value - (/* value= */ - diff, - /* account= */ (diff < 0L ? - losses_equity_account : - gains_equity_account), - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ *xact._date, - /* act_date_p= */ true, - /* total= */ value_t(), - /* direct_amount= */ false, - /* mark_visited= */ true); + handle_value + (/* value= */ - diff, + /* account= */ (diff < 0L ? + losses_equity_account : + gains_equity_account), + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ *xact._date, + /* act_date_p= */ true, + /* total= */ value_t(), + /* direct_amount= */ false, + /* mark_visited= */ true); } } } } -void changed_value_posts::output_intermediate_prices(post_t& post, - const date_t& current) +void changed_value_posts::output_intermediate_prices(post_t& post, + const date_t& current) { // To fix BZ#199, examine the balance of last_post and determine whether the // price of that amount changed after its date and before the new post's @@ -783,24 +783,24 @@ void changed_value_posts::output_intermediate_prices(post_t& post, commodity_t::history_map all_prices; foreach (const balance_t::amounts_map::value_type& amt_comm, - display_total.as_balance().amounts) { + display_total.as_balance().amounts) { if (optional<commodity_t::varied_history_t&> hist = - amt_comm.first->varied_history()) { - foreach - (const commodity_t::history_by_commodity_map::value_type& comm_hist, - hist->histories) { - foreach (const commodity_t::history_map::value_type& price, - comm_hist.second.prices) { - if (price.first.date() > post.value_date() && - price.first.date() < current) { - DEBUG("filters.revalued", post.value_date() << " < " - << price.first.date() << " < " << current); - DEBUG("filters.revalued", "inserting " - << price.second << " at " << price.first.date()); - all_prices.insert(price); - } - } - } + amt_comm.first->varied_history()) { + foreach + (const commodity_t::history_by_commodity_map::value_type& comm_hist, + hist->histories) { + foreach (const commodity_t::history_map::value_type& price, + comm_hist.second.prices) { + if (price.first.date() > post.value_date() && + price.first.date() < current) { + DEBUG("filters.revalued", post.value_date() << " < " + << price.first.date() << " < " << current); + DEBUG("filters.revalued", "inserting " + << price.second << " at " << price.first.date()); + all_prices.insert(price); + } + } + } } } @@ -813,7 +813,7 @@ void changed_value_posts::output_intermediate_prices(post_t& post, // This insert will fail if a later price has already been inserted // for that date. DEBUG("filters.revalued", - "re-inserting " << price.second << " at " << price.first.date()); + "re-inserting " << price.second << " at " << price.first.date()); pricing_dates.insert(date_map::value_type(price.first.date(), true)); } @@ -849,8 +849,8 @@ void changed_value_posts::operator()(post_t& post) last_post = &post; } -void subtotal_posts::report_subtotal(const char * spec_fmt, - const optional<date_interval_t>& interval) +void subtotal_posts::report_subtotal(const char * spec_fmt, + const optional<date_interval_t>& interval) { if (component_posts.empty()) return; @@ -860,12 +860,12 @@ void subtotal_posts::report_subtotal(const char * spec_fmt, if (! range_start || ! range_finish) { foreach (post_t * post, component_posts) { - date_t date = post->date(); + date_t date = post->date(); date_t value_date = post->value_date(); if (! range_start || date < *range_start) - range_start = date; + range_start = date; if (! range_finish || value_date > *range_finish) - range_finish = value_date; + range_finish = value_date; } } component_posts.clear(); @@ -876,7 +876,7 @@ void subtotal_posts::report_subtotal(const char * spec_fmt, } else if (date_format) { out_date << "- " << format_date(*range_finish, FMT_CUSTOM, - date_format->c_str()); + date_format->c_str()); } else { out_date << "- " << format_date(*range_finish); @@ -888,12 +888,12 @@ void subtotal_posts::report_subtotal(const char * spec_fmt, foreach (values_map::value_type& pair, values) handle_value(/* value= */ pair.second.value, - /* account= */ pair.second.account, - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ *range_finish, - /* act_date_p= */ false); + /* account= */ pair.second.account, + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ *range_finish, + /* act_date_p= */ false); values.clear(); } @@ -952,25 +952,25 @@ void interval_posts::operator()(post_t& post) report_subtotal(last_interval); if (generate_empty_posts) { - for (++last_interval; interval != last_interval; ++last_interval) { - // Generate a null posting, so the intervening periods can be - // seen when -E is used, or if the calculated amount ends up being - // non-zero - xact_t& null_xact = temps.create_xact(); - null_xact._date = last_interval.inclusive_end(); - - post_t& null_post = temps.create_post(null_xact, &empty_account); - null_post.add_flags(POST_CALCULATED); - null_post.amount = 0L; - - last_post = &null_post; - subtotal_posts::operator()(null_post); - - report_subtotal(last_interval); - } - assert(interval == last_interval); + for (++last_interval; interval != last_interval; ++last_interval) { + // Generate a null posting, so the intervening periods can be + // seen when -E is used, or if the calculated amount ends up being + // non-zero + xact_t& null_xact = temps.create_xact(); + null_xact._date = last_interval.inclusive_end(); + + post_t& null_post = temps.create_post(null_xact, &empty_account); + null_post.add_flags(POST_CALCULATED); + null_post.amount = 0L; + + last_post = &null_post; + subtotal_posts::operator()(null_post); + + report_subtotal(last_interval); + } + assert(interval == last_interval); } else { - last_interval = interval; + last_interval = interval; } } else { last_interval = interval; @@ -1001,22 +1001,22 @@ void posts_as_equity::report_subtotal() foreach (values_map::value_type& pair, values) { if (pair.second.value.is_balance()) { foreach (const balance_t::amounts_map::value_type& amount_pair, - pair.second.value.as_balance().amounts) - handle_value(/* value= */ amount_pair.second, - /* account= */ pair.second.account, - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ finish, - /* act_date_p= */ false); + pair.second.value.as_balance().amounts) + handle_value(/* value= */ amount_pair.second, + /* account= */ pair.second.account, + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ finish, + /* act_date_p= */ false); } else { handle_value(/* value= */ pair.second.value, - /* account= */ pair.second.account, - /* xact= */ &xact, - /* temps= */ temps, - /* handler= */ handler, - /* date= */ finish, - /* act_date_p= */ false); + /* account= */ pair.second.account, + /* xact= */ &xact, + /* temps= */ temps, + /* handler= */ handler, + /* date= */ finish, + /* act_date_p= */ false); } total += pair.second.value; } @@ -1024,7 +1024,7 @@ void posts_as_equity::report_subtotal() if (total.is_balance()) { foreach (const balance_t::amounts_map::value_type& pair, - total.as_balance().amounts) { + total.as_balance().amounts) { post_t& balance_post = temps.create_post(xact, balance_account); balance_post.amount = - pair.second; (*handler)(balance_post); @@ -1052,7 +1052,7 @@ void by_payee_posts::operator()(post_t& post) if (i == payee_subtotals.end()) { payee_subtotals_pair temp(post.xact->payee, - shared_ptr<subtotal_posts>(new subtotal_posts(handler, amount_expr))); + shared_ptr<subtotal_posts>(new subtotal_posts(handler, amount_expr))); std::pair<payee_subtotals_map::iterator, bool> result = payee_subtotals.insert(temp); @@ -1085,22 +1085,22 @@ void transfer_details::operator()(post_t& post) case SET_ACCOUNT: { string account_name = substitute.to_string(); if (! account_name.empty() && - account_name[account_name.length() - 1] != ':') { - account_t * prev_account = temp.account; - temp.account->remove_post(&temp); - - account_name += ':'; - account_name += prev_account->fullname(); - - std::list<string> account_names; - split_string(account_name, ':', account_names); - temp.account = create_temp_account_from_path(account_names, temps, - xact.journal->master); - temp.account->add_post(&temp); - - temp.account->add_flags(prev_account->flags()); - if (prev_account->has_xdata()) - temp.account->xdata().add_flags(prev_account->xdata().flags()); + account_name[account_name.length() - 1] != ':') { + account_t * prev_account = temp.account; + temp.account->remove_post(&temp); + + account_name += ':'; + account_name += prev_account->fullname(); + + std::list<string> account_names; + split_string(account_name, ':', account_names); + temp.account = create_temp_account_from_path(account_names, temps, + xact.journal->master); + temp.account->add_post(&temp); + + temp.account->add_flags(prev_account->flags()); + if (prev_account->has_xdata()) + temp.account->xdata().add_flags(prev_account->xdata().flags()); } break; } @@ -1153,41 +1153,41 @@ void budget_posts::report_budget_items(const date_t& date) foreach (pending_posts_list::value_type& pair, pending_posts) { optional<date_t> begin = pair.first.start; if (! begin) { - if (! pair.first.find_period(date)) - continue; - begin = pair.first.start; + if (! pair.first.find_period(date)) + continue; + begin = pair.first.start; } assert(begin); if (*begin <= date && - (! pair.first.finish || *begin < *pair.first.finish)) { - post_t& post = *pair.second; + (! pair.first.finish || *begin < *pair.first.finish)) { + post_t& post = *pair.second; - DEBUG("budget.generate", "Reporting budget for " - << post.reported_account()->fullname()); + DEBUG("budget.generate", "Reporting budget for " + << post.reported_account()->fullname()); - xact_t& xact = temps.create_xact(); - xact.payee = _("Budget transaction"); - xact._date = begin; + xact_t& xact = temps.create_xact(); + xact.payee = _("Budget transaction"); + xact._date = begin; - post_t& temp = temps.copy_post(post, xact); - temp.amount.in_place_negate(); + post_t& temp = temps.copy_post(post, xact); + temp.amount.in_place_negate(); - if (flags & BUDGET_WRAP_VALUES) { - value_t seq; - seq.push_back(0L); - seq.push_back(temp.amount); + if (flags & BUDGET_WRAP_VALUES) { + value_t seq; + seq.push_back(0L); + seq.push_back(temp.amount); - temp.xdata().compound_value = seq; - temp.xdata().add_flags(POST_EXT_COMPOUND); - } + temp.xdata().compound_value = seq; + temp.xdata().add_flags(POST_EXT_COMPOUND); + } - ++pair.first; - begin = *pair.first.start; + ++pair.first; + begin = *pair.first.start; - item_handler<post_t>::operator()(temp); + item_handler<post_t>::operator()(temp); - reported = true; + reported = true; } } } while (reported); @@ -1199,14 +1199,14 @@ void budget_posts::operator()(post_t& post) foreach (pending_posts_list::value_type& pair, pending_posts) { for (account_t * acct = post.reported_account(); - acct; - acct = acct->parent) { + acct; + acct = acct->parent) { if (acct == (*pair.second).reported_account()) { - post_in_budget = true; - // Report the post as if it had occurred in the parent account. - if (post.reported_account() != acct) - post.set_reported_account(acct); - goto handle; + post_in_budget = true; + // Report the post as if it had occurred in the parent account. + if (post.reported_account() != acct) + post.set_reported_account(acct); + goto handle; } } } @@ -1274,10 +1274,10 @@ void forecast_posts::flush() // period contains the earliest starting date. pending_posts_list::iterator least = pending_posts.begin(); for (pending_posts_list::iterator i = ++pending_posts.begin(); - i != pending_posts.end(); - i++) { + i != pending_posts.end(); + i++) { if (*(*i).first.start < *(*least).first.start) - least = i; + least = i; } date_t& begin = *(*least).first.start; @@ -1293,10 +1293,10 @@ void forecast_posts::flush() assert(next > begin); if (static_cast<std::size_t>((next - last).days()) > - static_cast<std::size_t>(365U) * forecast_years) { + static_cast<std::size_t>(365U) * forecast_years) { DEBUG("filters.forecast", - "Forecast transaction exceeds " << forecast_years - << " years beyond today"); + "Forecast transaction exceeds " << forecast_years + << " years beyond today"); pending_posts.erase(least); continue; } @@ -1309,15 +1309,15 @@ void forecast_posts::flush() // "Forecast transaction". post_t& post = *(*least).second; xact_t& xact = temps.create_xact(); - xact.payee = _("Forecast transaction"); - xact._date = begin; + xact.payee = _("Forecast transaction"); + xact._date = begin; post_t& temp = temps.copy_post(post, xact); // Submit the generated posting DEBUG("filters.forecast", - "Forecast transaction: " << temp.date() - << " " << temp.account->fullname() - << " " << temp.amount); + "Forecast transaction: " << temp.date() + << " " << temp.account->fullname() + << " " << temp.amount); item_handler<post_t>::operator()(temp); // If the generated posting matches the user's report query, check whether @@ -1327,9 +1327,9 @@ void forecast_posts::flush() DEBUG("filters.forecast", " matches report query"); bind_scope_t bound_scope(context, temp); if (! pred(bound_scope)) { - DEBUG("filters.forecast", " fails to match continuation criteria"); - pending_posts.erase(least); - continue; + DEBUG("filters.forecast", " fails to match continuation criteria"); + pending_posts.erase(least); + continue; } } } @@ -1337,10 +1337,10 @@ void forecast_posts::flush() item_handler<post_t>::flush(); } -pass_down_accounts::pass_down_accounts(acct_handler_ptr handler, - accounts_iterator& iter, - const optional<predicate_t>& _pred, - const optional<scope_t&>& _context) +pass_down_accounts::pass_down_accounts(acct_handler_ptr handler, + accounts_iterator& iter, + const optional<predicate_t>& _pred, + const optional<scope_t&>& _context) : item_handler<account_t>(handler), pred(_pred), context(_context) { TRACE_CTOR(pass_down_accounts, "acct_handler_ptr, accounts_iterator, ..."); @@ -1351,7 +1351,7 @@ pass_down_accounts::pass_down_accounts(acct_handler_ptr handler, } else { bind_scope_t bound_scope(*context, *account); if ((*pred)(bound_scope)) - item_handler<account_t>::operator()(*account); + item_handler<account_t>::operator()(*account); } } diff --git a/src/filters.h b/src/filters.h index ffca9d1e..e981dcd4 100644 --- a/src/filters.h +++ b/src/filters.h @@ -62,17 +62,17 @@ public: typedef function<void (const value_t&)> custom_flusher_t; protected: - value_to_posts_map posts_map; - post_handler_ptr post_chain; - report_t& report; - expr_t group_by_expr; - custom_flusher_t preflush_func; + value_to_posts_map posts_map; + post_handler_ptr post_chain; + report_t& report; + expr_t group_by_expr; + custom_flusher_t preflush_func; optional<custom_flusher_t> postflush_func; public: post_splitter(post_handler_ptr _post_chain, - report_t& _report, - expr_t _group_by_expr) + report_t& _report, + expr_t _group_by_expr) : post_chain(_post_chain), report(_report), group_by_expr(_group_by_expr), preflush_func(bind(&post_splitter::print_title, this, _1)) { @@ -192,7 +192,7 @@ class truncate_xacts : public item_handler<post_t> public: truncate_xacts(post_handler_ptr handler, - int _head_count, int _tail_count) + int _head_count, int _tail_count) : item_handler<post_t>(handler), head_count(_head_count), tail_count(_tail_count), completed(false), xacts_seen(0), last_xact(NULL) { @@ -267,12 +267,12 @@ public: sort_xacts(post_handler_ptr handler, const expr_t& _sort_order) : sorter(handler, _sort_order) { TRACE_CTOR(sort_xacts, - "post_handler_ptr, const value_expr&"); + "post_handler_ptr, const value_expr&"); } sort_xacts(post_handler_ptr handler, const string& _sort_order) : sorter(handler, _sort_order) { TRACE_CTOR(sort_xacts, - "post_handler_ptr, const string&"); + "post_handler_ptr, const string&"); } virtual ~sort_xacts() { TRACE_DTOR(sort_xacts); @@ -308,9 +308,9 @@ class filter_posts : public item_handler<post_t> filter_posts(); public: - filter_posts(post_handler_ptr handler, - const predicate_t& predicate, - scope_t& _context) + filter_posts(post_handler_ptr handler, + const predicate_t& predicate, + scope_t& _context) : item_handler<post_t>(handler), pred(predicate), context(_context) { TRACE_CTOR(filter_posts, "post_handler_ptr, predicate_t, scope_t&"); } @@ -336,10 +336,10 @@ class anonymize_posts : public item_handler<post_t> { typedef std::map<commodity_t *, std::size_t> commodity_index_map; - temporaries_t temps; + temporaries_t temps; commodity_index_map comms; std::size_t next_comm_id; - xact_t * last_xact; + xact_t * last_xact; anonymize_posts(); @@ -374,8 +374,8 @@ class calc_posts : public item_handler<post_t> public: calc_posts(post_handler_ptr handler, - expr_t& _amount_expr, - bool _calc_running_total = false) + expr_t& _amount_expr, + bool _calc_running_total = false) : item_handler<post_t>(handler), last_post(NULL), amount_expr(_amount_expr), calc_running_total(_calc_running_total) { TRACE_CTOR(calc_posts, "post_handler_ptr, expr_t&, bool"); @@ -396,16 +396,16 @@ public: class collapse_posts : public item_handler<post_t> { - expr_t& amount_expr; - predicate_t display_predicate; - predicate_t only_predicate; - value_t subtotal; - std::size_t count; - xact_t * last_xact; - post_t * last_post; + expr_t& amount_expr; + predicate_t display_predicate; + predicate_t only_predicate; + value_t subtotal; + std::size_t count; + xact_t * last_xact; + post_t * last_post; temporaries_t temps; - account_t& totals_account; - bool only_collapse_if_zero; + account_t& totals_account; + bool only_collapse_if_zero; std::list<post_t *> component_posts; report_t& report; @@ -413,11 +413,11 @@ class collapse_posts : public item_handler<post_t> public: collapse_posts(post_handler_ptr handler, - report_t& _report, - expr_t& _amount_expr, - predicate_t _display_predicate, - predicate_t _only_predicate, - bool _only_collapse_if_zero = false) + report_t& _report, + expr_t& _amount_expr, + predicate_t _display_predicate, + predicate_t _only_predicate, + bool _only_collapse_if_zero = false) : item_handler<post_t>(handler), amount_expr(_amount_expr), display_predicate(_display_predicate), only_predicate(_only_predicate), count(0), @@ -459,17 +459,17 @@ public: class related_posts : public item_handler<post_t> { posts_list posts; - bool also_matching; + bool also_matching; related_posts(); public: related_posts(post_handler_ptr handler, - const bool _also_matching = false) + const bool _also_matching = false) : item_handler<post_t>(handler), also_matching(_also_matching) { TRACE_CTOR(related_posts, - "post_handler_ptr, const bool"); + "post_handler_ptr, const bool"); } virtual ~related_posts() throw() { TRACE_DTOR(related_posts); @@ -492,22 +492,22 @@ class display_filter_posts : public item_handler<post_t> // This filter requires that calc_posts be used at some point // later in the chain. - expr_t display_amount_expr; - expr_t display_total_expr; + expr_t display_amount_expr; + expr_t display_total_expr; report_t& report; - bool show_rounding; - value_t last_display_total; - temporaries_t temps; - account_t& rounding_account; + bool show_rounding; + value_t last_display_total; + temporaries_t temps; + account_t& rounding_account; display_filter_posts(); public: - account_t& revalued_account; + account_t& revalued_account; display_filter_posts(post_handler_ptr handler, - report_t& _report, - bool _show_rounding); + report_t& _report, + bool _show_rounding); virtual ~display_filter_posts() { TRACE_DTOR(display_filter_posts); @@ -534,30 +534,30 @@ class changed_value_posts : public item_handler<post_t> // This filter requires that calc_posts be used at some point // later in the chain. - expr_t total_expr; - expr_t display_total_expr; - report_t& report; - bool changed_values_only; - bool for_accounts_report; - bool show_unrealized; - post_t * last_post; - value_t last_total; + expr_t total_expr; + expr_t display_total_expr; + report_t& report; + bool changed_values_only; + bool for_accounts_report; + bool show_unrealized; + post_t * last_post; + value_t last_total; value_t repriced_total; - temporaries_t temps; - account_t& revalued_account; - account_t * gains_equity_account; - account_t * losses_equity_account; + temporaries_t temps; + account_t& revalued_account; + account_t * gains_equity_account; + account_t * losses_equity_account; display_filter_posts * display_filter; changed_value_posts(); public: - changed_value_posts(post_handler_ptr handler, - report_t& _report, - bool _for_accounts_report, - bool _show_unrealized, - display_filter_posts * _display_filter); + changed_value_posts(post_handler_ptr handler, + report_t& _report, + bool _for_accounts_report, + bool _show_unrealized, + display_filter_posts * _display_filter); virtual ~changed_value_posts() { TRACE_DTOR(changed_value_posts); @@ -593,8 +593,8 @@ protected: acct_value_t(); public: - account_t * account; - value_t value; + account_t * account; + value_t value; acct_value_t(account_t * a) : account(a) { TRACE_CTOR(acct_value_t, "account_t *"); @@ -615,26 +615,26 @@ protected: typedef std::pair<string, acct_value_t> values_pair; protected: - expr_t& amount_expr; - values_map values; + expr_t& amount_expr; + values_map values; optional<string> date_format; temporaries_t temps; std::list<post_t *> component_posts; public: subtotal_posts(post_handler_ptr handler, expr_t& _amount_expr, - const optional<string>& _date_format = none) + const optional<string>& _date_format = none) : item_handler<post_t>(handler), amount_expr(_amount_expr), date_format(_date_format) { TRACE_CTOR(subtotal_posts, - "post_handler_ptr, expr_t&, const optional<string>&"); + "post_handler_ptr, expr_t&, const optional<string>&"); } virtual ~subtotal_posts() { TRACE_DTOR(subtotal_posts); } void report_subtotal(const char * spec_fmt = NULL, - const optional<date_interval_t>& interval = none); + const optional<date_interval_t>& interval = none); virtual void flush() { if (values.size() > 0) @@ -658,27 +658,27 @@ class interval_posts : public subtotal_posts date_interval_t start_interval; date_interval_t interval; date_interval_t last_interval; - post_t * last_post; - account_t& empty_account; - bool exact_periods; - bool generate_empty_posts; + post_t * last_post; + account_t& empty_account; + bool exact_periods; + bool generate_empty_posts; interval_posts(); public: - interval_posts(post_handler_ptr _handler, - expr_t& amount_expr, - const date_interval_t& _interval, - bool _exact_periods = false, - bool _generate_empty_posts = false) + interval_posts(post_handler_ptr _handler, + expr_t& amount_expr, + const date_interval_t& _interval, + bool _exact_periods = false, + bool _generate_empty_posts = false) : subtotal_posts(_handler, amount_expr), start_interval(_interval), interval(start_interval), last_post(NULL), empty_account(temps.create_account(_("<None>"))), exact_periods(_exact_periods), generate_empty_posts(_generate_empty_posts) { TRACE_CTOR(interval_posts, - "post_handler_ptr, expr_t&, date_interval_t, bool, bool"); + "post_handler_ptr, expr_t&, date_interval_t, bool, bool"); } virtual ~interval_posts() throw() { TRACE_DTOR(interval_posts); @@ -689,7 +689,7 @@ public: virtual void flush() { if (last_post && interval.duration) { if (interval.is_valid()) - report_subtotal(interval); + report_subtotal(interval); subtotal_posts::flush(); } } @@ -741,7 +741,7 @@ class by_payee_posts : public item_handler<post_t> typedef std::map<string, shared_ptr<subtotal_posts> > payee_subtotals_map; typedef std::pair<string, shared_ptr<subtotal_posts> > payee_subtotals_pair; - expr_t& amount_expr; + expr_t& amount_expr; payee_subtotals_map payee_subtotals; by_payee_posts(); @@ -768,9 +768,9 @@ class by_payee_posts : public item_handler<post_t> class transfer_details : public item_handler<post_t> { - account_t * master; - expr_t expr; - scope_t& scope; + account_t * master; + expr_t expr; + scope_t& scope; temporaries_t temps; transfer_details(); @@ -783,14 +783,14 @@ public: } which_element; transfer_details(post_handler_ptr handler, - element_t _which_element, - account_t * _master, - const expr_t& _expr, - scope_t& _scope) + element_t _which_element, + account_t * _master, + const expr_t& _expr, + scope_t& _scope) : item_handler<post_t>(handler), master(_master), expr(_expr), scope(_scope), which_element(_which_element) { TRACE_CTOR(transfer_details, - "post_handler_ptr, element_t, account_t *, expr_t, scope_t&"); + "post_handler_ptr, element_t, account_t *, expr_t, scope_t&"); } virtual ~transfer_details() { TRACE_DTOR(transfer_details); @@ -840,7 +840,7 @@ class generate_posts : public item_handler<post_t> protected: typedef std::pair<date_interval_t, post_t *> pending_posts_pair; - typedef std::list<pending_posts_pair> pending_posts_list; + typedef std::list<pending_posts_pair> pending_posts_list; pending_posts_list pending_posts; temporaries_t temps; @@ -870,7 +870,7 @@ public: class budget_posts : public generate_posts { #define BUDGET_NO_BUDGET 0x00 -#define BUDGET_BUDGETED 0x01 +#define BUDGET_BUDGETED 0x01 #define BUDGET_UNBUDGETED 0x02 #define BUDGET_WRAP_VALUES 0x04 @@ -880,7 +880,7 @@ class budget_posts : public generate_posts public: budget_posts(post_handler_ptr handler, - uint_least8_t _flags = BUDGET_BUDGETED) + uint_least8_t _flags = BUDGET_BUDGETED) : generate_posts(handler), flags(_flags) { TRACE_CTOR(budget_posts, "post_handler_ptr, uint_least8_t"); } @@ -895,19 +895,19 @@ public: class forecast_posts : public generate_posts { - predicate_t pred; - scope_t& context; + predicate_t pred; + scope_t& context; const std::size_t forecast_years; public: forecast_posts(post_handler_ptr handler, - const predicate_t& predicate, - scope_t& _context, - const std::size_t _forecast_years) + const predicate_t& predicate, + scope_t& _context, + const std::size_t _forecast_years) : generate_posts(handler), pred(predicate), context(_context), forecast_years(_forecast_years) { TRACE_CTOR(forecast_posts, - "post_handler_ptr, predicate_t, scope_t&, std::size_t"); + "post_handler_ptr, predicate_t, scope_t&, std::size_t"); } virtual ~forecast_posts() throw() { TRACE_DTOR(forecast_posts); @@ -937,10 +937,10 @@ class pass_down_accounts : public item_handler<account_t> optional<scope_t&> context; public: - pass_down_accounts(acct_handler_ptr handler, - accounts_iterator& iter, - const optional<predicate_t>& _pred = none, - const optional<scope_t&>& _context = none); + pass_down_accounts(acct_handler_ptr handler, + accounts_iterator& iter, + const optional<predicate_t>& _pred = none, + const optional<scope_t&>& _context = none); virtual ~pass_down_accounts() { TRACE_DTOR(pass_down_accounts); diff --git a/src/format.cc b/src/format.cc index c546926e..bde39882 100644 --- a/src/format.cc +++ b/src/format.cc @@ -37,8 +37,8 @@ namespace ledger { -format_t::elision_style_t format_t::default_style = TRUNCATE_TRAILING; -bool format_t::default_style_changed = false; +format_t::elision_style_t format_t::default_style = TRUNCATE_TRAILING; +bool format_t::default_style_changed = false; void format_t::element_t::dump(std::ostream& out) const { @@ -88,14 +88,14 @@ namespace { // Don't gobble up any whitespace const char * base = p; while (p >= base && std::isspace(*p)) - p--; + p--; } return expr; } } format_t::element_t * format_t::parse_elements(const string& fmt, - const optional<format_t&>& tmpl) + const optional<format_t&>& tmpl) { std::auto_ptr<element_t> result; @@ -147,8 +147,8 @@ format_t::element_t * format_t::parse_elements(const string& fmt, while (*p == '-') { switch (*p) { case '-': - current->add_flags(ELEMENT_ALIGN_LEFT); - break; + current->add_flags(ELEMENT_ALIGN_LEFT); + break; } ++p; } @@ -164,12 +164,12 @@ format_t::element_t * format_t::parse_elements(const string& fmt, ++p; num = 0; while (*p && std::isdigit(*p)) { - num *= 10; - num += *p++ - '0'; + num *= 10; + num += *p++ - '0'; } current->max_width = num; if (current->min_width == 0) - current->min_width = current->max_width; + current->min_width = current->max_width; } switch (*p) { @@ -180,25 +180,25 @@ format_t::element_t * format_t::parse_elements(const string& fmt, case '$': { if (! tmpl) - throw_(format_error, _("Prior field reference, but no template")); + throw_(format_error, _("Prior field reference, but no template")); p++; if (*p == '0' || (! std::isdigit(*p) && - *p != 'A' && *p != 'B' && *p != 'C' && - *p != 'D' && *p != 'E' && *p != 'F')) - throw_(format_error, _("%$ field reference must be a digit from 1-9")); + *p != 'A' && *p != 'B' && *p != 'C' && + *p != 'D' && *p != 'E' && *p != 'F')) + throw_(format_error, _("%$ field reference must be a digit from 1-9")); unsigned int index = std::isdigit(*p) ? *p - '0' : (*p - 'A' + 10); element_t * tmpl_elem = tmpl->elements.get(); for (unsigned int i = 1; i < index && tmpl_elem; i++) { - tmpl_elem = tmpl_elem->next.get(); - while (tmpl_elem && tmpl_elem->type != element_t::EXPR) - tmpl_elem = tmpl_elem->next.get(); + tmpl_elem = tmpl_elem->next.get(); + while (tmpl_elem && tmpl_elem->type != element_t::EXPR) + tmpl_elem = tmpl_elem->next.get(); } if (! tmpl_elem) - throw_(format_error, _("%$ reference to a non-existent prior field")); + throw_(format_error, _("%$ reference to a non-existent prior field")); *current = *tmpl_elem; break; @@ -214,87 +214,87 @@ format_t::element_t * format_t::parse_elements(const string& fmt, // Wrap the subexpression in calls to justify and scrub if (format_amount) { - if (! *p || *(p + 1) != '}') - throw_(format_error, _("Expected closing brace")); - else - p++; + if (! *p || *(p + 1) != '}') + throw_(format_error, _("Expected closing brace")); + else + p++; - expr_t::ptr_op_t op = boost::get<expr_t>(current->data).get_op(); + expr_t::ptr_op_t op = boost::get<expr_t>(current->data).get_op(); - expr_t::ptr_op_t amount_op; - expr_t::ptr_op_t colorize_op; - if (op->kind == expr_t::op_t::O_CONS) { - amount_op = op->left(); - colorize_op = op->right(); - } else { - amount_op = op; - } + expr_t::ptr_op_t amount_op; + expr_t::ptr_op_t colorize_op; + if (op->kind == expr_t::op_t::O_CONS) { + amount_op = op->left(); + colorize_op = op->right(); + } else { + amount_op = op; + } - expr_t::ptr_op_t scrub_node(new expr_t::op_t(expr_t::op_t::IDENT)); - scrub_node->set_ident("scrub"); + expr_t::ptr_op_t scrub_node(new expr_t::op_t(expr_t::op_t::IDENT)); + scrub_node->set_ident("scrub"); - expr_t::ptr_op_t call1_node(new expr_t::op_t(expr_t::op_t::O_CALL)); - call1_node->set_left(scrub_node); - call1_node->set_right(amount_op); + expr_t::ptr_op_t call1_node(new expr_t::op_t(expr_t::op_t::O_CALL)); + call1_node->set_left(scrub_node); + call1_node->set_right(amount_op); - expr_t::ptr_op_t arg1_node(new expr_t::op_t(expr_t::op_t::VALUE)); - expr_t::ptr_op_t arg2_node(new expr_t::op_t(expr_t::op_t::VALUE)); - expr_t::ptr_op_t arg3_node(new expr_t::op_t(expr_t::op_t::VALUE)); + expr_t::ptr_op_t arg1_node(new expr_t::op_t(expr_t::op_t::VALUE)); + expr_t::ptr_op_t arg2_node(new expr_t::op_t(expr_t::op_t::VALUE)); + expr_t::ptr_op_t arg3_node(new expr_t::op_t(expr_t::op_t::VALUE)); - arg1_node->set_value(current->min_width > 0 ? - long(current->min_width) : -1); - arg2_node->set_value(current->max_width > 0 ? - long(current->max_width) : -1); - arg3_node->set_value(! current->has_flags(ELEMENT_ALIGN_LEFT)); + arg1_node->set_value(current->min_width > 0 ? + long(current->min_width) : -1); + arg2_node->set_value(current->max_width > 0 ? + long(current->max_width) : -1); + arg3_node->set_value(! current->has_flags(ELEMENT_ALIGN_LEFT)); - current->min_width = 0; - current->max_width = 0; + current->min_width = 0; + current->max_width = 0; - expr_t::ptr_op_t args1_node(new expr_t::op_t(expr_t::op_t::O_CONS)); - args1_node->set_left(arg2_node); - args1_node->set_right(arg3_node); + expr_t::ptr_op_t args1_node(new expr_t::op_t(expr_t::op_t::O_CONS)); + args1_node->set_left(arg2_node); + args1_node->set_right(arg3_node); - expr_t::ptr_op_t args2_node(new expr_t::op_t(expr_t::op_t::O_CONS)); - args2_node->set_left(arg1_node); - args2_node->set_right(args1_node); + expr_t::ptr_op_t args2_node(new expr_t::op_t(expr_t::op_t::O_CONS)); + args2_node->set_left(arg1_node); + args2_node->set_right(args1_node); - expr_t::ptr_op_t args3_node(new expr_t::op_t(expr_t::op_t::O_CONS)); - args3_node->set_left(call1_node); - args3_node->set_right(args2_node); + expr_t::ptr_op_t args3_node(new expr_t::op_t(expr_t::op_t::O_CONS)); + args3_node->set_left(call1_node); + args3_node->set_right(args2_node); - expr_t::ptr_op_t seq1_node(new expr_t::op_t(expr_t::op_t::O_SEQ)); - seq1_node->set_left(args3_node); + expr_t::ptr_op_t seq1_node(new expr_t::op_t(expr_t::op_t::O_SEQ)); + seq1_node->set_left(args3_node); - expr_t::ptr_op_t justify_node(new expr_t::op_t(expr_t::op_t::IDENT)); - justify_node->set_ident("justify"); + expr_t::ptr_op_t justify_node(new expr_t::op_t(expr_t::op_t::IDENT)); + justify_node->set_ident("justify"); - expr_t::ptr_op_t call2_node(new expr_t::op_t(expr_t::op_t::O_CALL)); - call2_node->set_left(justify_node); - call2_node->set_right(seq1_node); + expr_t::ptr_op_t call2_node(new expr_t::op_t(expr_t::op_t::O_CALL)); + call2_node->set_left(justify_node); + call2_node->set_right(seq1_node); - string prev_expr = boost::get<expr_t>(current->data).text(); + string prev_expr = boost::get<expr_t>(current->data).text(); - if (colorize_op) { - expr_t::ptr_op_t ansify_if_node(new expr_t::op_t(expr_t::op_t::IDENT)); - ansify_if_node->set_ident("ansify_if"); + if (colorize_op) { + expr_t::ptr_op_t ansify_if_node(new expr_t::op_t(expr_t::op_t::IDENT)); + ansify_if_node->set_ident("ansify_if"); - expr_t::ptr_op_t args4_node(new expr_t::op_t(expr_t::op_t::O_CONS)); - args4_node->set_left(call2_node); - args4_node->set_right(colorize_op); + expr_t::ptr_op_t args4_node(new expr_t::op_t(expr_t::op_t::O_CONS)); + args4_node->set_left(call2_node); + args4_node->set_right(colorize_op); - expr_t::ptr_op_t seq2_node(new expr_t::op_t(expr_t::op_t::O_SEQ)); - seq2_node->set_left(args4_node); + expr_t::ptr_op_t seq2_node(new expr_t::op_t(expr_t::op_t::O_SEQ)); + seq2_node->set_left(args4_node); - expr_t::ptr_op_t call3_node(new expr_t::op_t(expr_t::op_t::O_CALL)); - call3_node->set_left(ansify_if_node); - call3_node->set_right(seq2_node); + expr_t::ptr_op_t call3_node(new expr_t::op_t(expr_t::op_t::O_CALL)); + call3_node->set_left(ansify_if_node); + call3_node->set_right(seq2_node); - current->data = expr_t(call3_node); - } else { - current->data = expr_t(call2_node); - } + current->data = expr_t(call3_node); + } else { + current->data = expr_t(call2_node); + } - boost::get<expr_t>(current->data).set_text(prev_expr); + boost::get<expr_t>(current->data).set_text(prev_expr); } break; } @@ -335,7 +335,7 @@ string format_t::real_calc(scope_t& scope) switch (elem->type) { case element_t::STRING: if (elem->min_width > 0) - out.width(elem->min_width); + out.width(elem->min_width); out << boost::get<string>(elem->data); break; @@ -343,28 +343,28 @@ string format_t::real_calc(scope_t& scope) expr_t& expr(boost::get<expr_t>(elem->data)); try { - expr.compile(scope); - - value_t value; - if (expr.is_function()) { - call_scope_t args(scope); - args.push_back(long(elem->max_width)); - value = expr.get_function()(args); - } else { - value = expr.calc(scope); - } - DEBUG("format.expr", "value = (" << value << ")"); - - if (elem->min_width > 0) - value.print(out, static_cast<int>(elem->min_width), -1, - ! elem->has_flags(ELEMENT_ALIGN_LEFT)); - else - out << value.to_string(); + expr.compile(scope); + + value_t value; + if (expr.is_function()) { + call_scope_t args(scope); + args.push_back(long(elem->max_width)); + value = expr.get_function()(args); + } else { + value = expr.calc(scope); + } + DEBUG("format.expr", "value = (" << value << ")"); + + if (elem->min_width > 0) + value.print(out, static_cast<int>(elem->min_width), -1, + ! elem->has_flags(ELEMENT_ALIGN_LEFT)); + else + out << value.to_string(); } catch (const calc_error&) { - add_error_context(_("While calculating format expression:")); - add_error_context(expr.context_to_str()); - throw; + add_error_context(_("While calculating format expression:")); + add_error_context(expr.context_to_str()); + throw; } break; } @@ -376,15 +376,15 @@ string format_t::real_calc(scope_t& scope) if (elem->max_width > 0 || elem->min_width > 0) { unistring temp(out.str()); - string result; + string result; if (elem->max_width > 0 && elem->max_width < temp.length()) { - result = truncate(temp, elem->max_width); + result = truncate(temp, elem->max_width); } else { - result = temp.extract(); - if (elem->min_width > temp.length()) - for (std::size_t i = 0; i < elem->min_width - temp.length(); i++) - result += " "; + result = temp.extract(); + if (elem->min_width > temp.length()) + for (std::size_t i = 0; i < elem->min_width - temp.length(); i++) + result += " "; } out_str << result; } else { @@ -396,8 +396,8 @@ string format_t::real_calc(scope_t& scope) } string format_t::truncate(const unistring& ustr, - const std::size_t width, - const std::size_t account_abbrev_length) + const std::size_t width, + const std::size_t account_abbrev_length) { assert(width < 4095); @@ -420,9 +420,9 @@ string format_t::truncate(const unistring& ustr, case TRUNCATE_MIDDLE: // This method truncates in the middle. buf << ustr.extract(0, (width - 2) / 2) - << ".." - << ustr.extract(len - ((width - 2) / 2 + (width - 2) % 2), - (width - 2) / 2 + (width - 2) % 2); + << ".." + << ustr.extract(len - ((width - 2) / 2 + (width - 2) % 2), + (width - 2) / 2 + (width - 2) % 2); break; case ABBREVIATE: @@ -431,46 +431,46 @@ string format_t::truncate(const unistring& ustr, string::size_type beg = 0; string strcopy(ustr.extract()); for (string::size_type pos = strcopy.find(':'); - pos != string::npos; - beg = pos + 1, pos = strcopy.find(':', beg)) - parts.push_back(string(strcopy, beg, pos - beg)); + pos != string::npos; + beg = pos + 1, pos = strcopy.find(':', beg)) + parts.push_back(string(strcopy, beg, pos - beg)); parts.push_back(string(strcopy, beg)); std::ostringstream result; std::size_t newlen = len; for (std::list<string>::iterator i = parts.begin(); - i != parts.end(); - i++) { - // Don't contract the last element - std::list<string>::iterator x = i; - if (++x == parts.end()) { - result << *i; - break; - } - - if (newlen > width) { - unistring temp(*i); - if (temp.length() > account_abbrev_length) { - result << temp.extract(0, account_abbrev_length) << ":"; - newlen -= temp.length() - account_abbrev_length; - } else { - result << temp.extract() << ":"; - newlen -= temp.length(); - } - } else { - result << *i << ":"; - } + i != parts.end(); + i++) { + // Don't contract the last element + std::list<string>::iterator x = i; + if (++x == parts.end()) { + result << *i; + break; + } + + if (newlen > width) { + unistring temp(*i); + if (temp.length() > account_abbrev_length) { + result << temp.extract(0, account_abbrev_length) << ":"; + newlen -= temp.length() - account_abbrev_length; + } else { + result << temp.extract() << ":"; + newlen -= temp.length(); + } + } else { + result << *i << ":"; + } } if (newlen > width) { - // Even abbreviated its too big to show the last account, so - // abbreviate all but the last and truncate at the beginning. - unistring temp(result.str()); - assert(temp.length() > width - 2); - buf << ".." << temp.extract(temp.length() - (width - 2), width - 2); + // Even abbreviated its too big to show the last account, so + // abbreviate all but the last and truncate at the beginning. + unistring temp(result.str()); + assert(temp.length() > width - 2); + buf << ".." << temp.extract(temp.length() - (width - 2), width - 2); } else { - buf << result.str(); + buf << result.str(); } break; } diff --git a/src/format.h b/src/format.h index 72d44ee5..a0b95567 100644 --- a/src/format.h +++ b/src/format.h @@ -61,10 +61,10 @@ class format_t : public expr_base_t<string> enum kind_t { STRING, EXPR }; - kind_t type; - std::size_t min_width; - std::size_t max_width; - variant<string, expr_t> data; + kind_t type; + std::size_t min_width; + std::size_t max_width; + variant<string, expr_t> data; scoped_ptr<struct element_t> next; element_t() throw() @@ -80,11 +80,11 @@ class format_t : public expr_base_t<string> element_t& operator=(const element_t& elem) { if (this != &elem) { - supports_flags<>::operator=(elem); - type = elem.type; - min_width = elem.min_width; - max_width = elem.max_width; - data = elem.data; + supports_flags<>::operator=(elem); + type = elem.type; + min_width = elem.min_width; + max_width = elem.max_width; + data = elem.data; } return *this; } @@ -95,12 +95,12 @@ class format_t : public expr_base_t<string> out << "\033[31m"; if (elem->has_flags(ELEMENT_ALIGN_LEFT)) - out << std::left; + out << std::left; else - out << std::right; + out << std::right; if (elem->min_width > 0) - out.width(elem->min_width); + out.width(elem->min_width); } void dump(std::ostream& out) const; @@ -120,7 +120,7 @@ public: private: static element_t * parse_elements(const string& fmt, - const optional<format_t&>& tmpl); + const optional<format_t&>& tmpl); public: format_t() : base_type() { @@ -137,7 +137,7 @@ public: } void parse_format(const string& _format, - const optional<format_t&>& tmpl = none) { + const optional<format_t&>& tmpl = none) { elements.reset(parse_elements(_format, tmpl)); set_text(_format); } @@ -146,14 +146,14 @@ public: virtual void dump(std::ostream& out) const { for (const element_t * elem = elements.get(); - elem; - elem = elem->next.get()) + elem; + elem = elem->next.get()) elem->dump(out); } static string truncate(const unistring& str, - const std::size_t width, - const std::size_t account_abbrev_length = 0); + const std::size_t width, + const std::size_t account_abbrev_length = 0); }; } // namespace ledger diff --git a/src/generate.cc b/src/generate.cc index 3f540b22..fbfca342 100644 --- a/src/generate.cc +++ b/src/generate.cc @@ -76,10 +76,10 @@ generate_posts_iterator::generate_posts_iterator } void generate_posts_iterator::generate_string(std::ostream& out, int len, - bool only_alpha) + bool only_alpha) { DEBUG("generate.post.string", - "Generating string of length " << len << ", only alpha " << only_alpha); + "Generating string of length " << len << ", only alpha " << only_alpha); int last = -1; bool first = true; @@ -87,38 +87,38 @@ void generate_posts_iterator::generate_string(std::ostream& out, int len, int next = only_alpha ? 3 : three_gen(); bool output = true; switch (next) { - case 1: // colon + case 1: // colon if (! first && last == 3 && strlen_gen() % 10 == 0 && i + 1 != len) - out << ':'; + out << ':'; else { - i--; - output = false; + i--; + output = false; } break; - case 2: // space + case 2: // space if (! first && last == 3 && strlen_gen() % 20 == 0 && i + 1 != len) - out << ' '; + out << ' '; else { - i--; - output = false; + i--; + output = false; } break; - case 3: // character + case 3: // character switch (three_gen()) { - case 1: // uppercase - out << char(upchar_gen()); - break; - case 2: // lowercase - out << char(downchar_gen()); - break; - case 3: // number - if (! only_alpha && ! first) - out << char(numchar_gen()); - else { - i--; - output = false; - } - break; + case 1: // uppercase + out << char(upchar_gen()); + break; + case 2: // lowercase + out << char(downchar_gen()); + break; + case 3: // number + if (! only_alpha && ! first) + out << char(numchar_gen()); + else { + i--; + output = false; + } + break; } break; } @@ -130,7 +130,7 @@ void generate_posts_iterator::generate_string(std::ostream& out, int len, } bool generate_posts_iterator::generate_account(std::ostream& out, - bool no_virtual) + bool no_virtual) { bool must_balance = true; bool is_virtual = false; @@ -164,7 +164,7 @@ bool generate_posts_iterator::generate_account(std::ostream& out, } void generate_posts_iterator::generate_commodity(std::ostream& out, - const string& exclude) + const string& exclude) { string comm; do { @@ -173,21 +173,21 @@ void generate_posts_iterator::generate_commodity(std::ostream& out, comm = buf.str(); } while (comm == exclude || comm == "h" || comm == "m" || comm == "s" || - comm == "and" || comm == "any" || comm == "all" || comm == "div" || - comm == "false" || comm == "or" || comm == "not" || - comm == "true" || comm == "if" || comm == "else"); + comm == "and" || comm == "any" || comm == "all" || comm == "div" || + comm == "false" || comm == "or" || comm == "not" || + comm == "true" || comm == "if" || comm == "else"); out << comm; } string generate_posts_iterator::generate_amount(std::ostream& out, - value_t not_this_amount, - bool no_negative, - const string& exclude) + value_t not_this_amount, + bool no_negative, + const string& exclude) { std::ostringstream buf; - if (truth_gen()) { // commodity goes in front + if (truth_gen()) { // commodity goes in front generate_commodity(buf, exclude); if (truth_gen()) buf << ' '; @@ -262,7 +262,7 @@ void generate_posts_iterator::generate_cost(std::ostream& out, value_t amount) buf << " @@ "; if (! generate_amount(buf, amount, true, - amount.as_amount().commodity().symbol()).empty()) + amount.as_amount().commodity().symbol()).empty()) out << buf.str(); } @@ -362,20 +362,20 @@ post_t * generate_posts_iterator::operator()() std::istringstream in(buf.str()); try { if (session.journal->parse(in, session) != 0) { - VERIFY(session.journal->xacts.back()->valid()); - posts.reset(*session.journal->xacts.back()); - post = posts(); + VERIFY(session.journal->xacts.back()->valid()); + posts.reset(*session.journal->xacts.back()); + post = posts(); } } catch (std::exception& err) { add_error_context(_("While parsing generated transaction (seed %1):") - << seed); + << seed); add_error_context(buf.str()); throw; } catch (int status) { add_error_context(_("While parsing generated transaction (seed %1):") - << seed); + << seed); add_error_context(buf.str()); throw; } diff --git a/src/generate.h b/src/generate.h index f0f58064..25ad41ea 100644 --- a/src/generate.h +++ b/src/generate.h @@ -53,7 +53,7 @@ class generate_posts_iterator : public posts_iterator session_t& session; unsigned int seed; std::size_t quantity; - bool allow_invalid; + bool allow_invalid; date_t next_date; date_t next_eff_date; @@ -97,9 +97,9 @@ class generate_posts_iterator : public posts_iterator public: generate_posts_iterator(session_t& _session, - unsigned int _seed = 0, - std::size_t _quantity = 100, - bool _allow_invalid = false); + unsigned int _seed = 0, + std::size_t _quantity = 100, + bool _allow_invalid = false); virtual ~generate_posts_iterator() throw() { TRACE_DTOR(generate_posts_iterator); @@ -108,21 +108,21 @@ public: virtual post_t * operator()(); protected: - void generate_string(std::ostream& out, int len, bool only_alpha = false); - bool generate_account(std::ostream& out, bool no_virtual = false); - void generate_commodity(std::ostream& out, const string& exclude = ""); + void generate_string(std::ostream& out, int len, bool only_alpha = false); + bool generate_account(std::ostream& out, bool no_virtual = false); + void generate_commodity(std::ostream& out, const string& exclude = ""); string generate_amount(std::ostream& out, - value_t not_this_amount = NULL_VALUE, - bool no_negative = false, - const string& exclude = ""); - bool generate_post(std::ostream& out, bool no_amount = false); - void generate_cost(std::ostream& out, value_t amount); - void generate_date(std::ostream& out); - void generate_state(std::ostream& out); - void generate_code(std::ostream& out); - void generate_payee(std::ostream& out); - void generate_note(std::ostream& out); - void generate_xact(std::ostream& out); + value_t not_this_amount = NULL_VALUE, + bool no_negative = false, + const string& exclude = ""); + bool generate_post(std::ostream& out, bool no_amount = false); + void generate_cost(std::ostream& out, value_t amount); + void generate_date(std::ostream& out); + void generate_state(std::ostream& out); + void generate_code(std::ostream& out); + void generate_payee(std::ostream& out); + void generate_note(std::ostream& out); + void generate_xact(std::ostream& out); }; } // namespace ledger diff --git a/src/global.cc b/src/global.cc index 35651ddb..eb138f25 100644 --- a/src/global.cc +++ b/src/global.cc @@ -113,10 +113,10 @@ void global_scope_t::read_init() ifstream init(init_file); if (session().journal->read(init_file, NULL, &report()) > 0 || - session().journal->auto_xacts.size() > 0 || - session().journal->period_xacts.size() > 0) { - throw_(parse_error, _("Transactions found in initialization file '%1'") - << init_file); + session().journal->auto_xacts.size() > 0 || + session().journal->period_xacts.size() > 0) { + throw_(parse_error, _("Transactions found in initialization file '%1'") + << init_file); } TRACE_FINISH(init, 1); @@ -137,7 +137,7 @@ char * global_scope_t::prompt_string() void global_scope_t::report_error(const std::exception& err) { - std::cout.flush(); // first display anything that was pending + std::cout.flush(); // first display anything that was pending if (caught_signal == NONE_CAUGHT) { // Display any pending error context information @@ -163,7 +163,7 @@ void global_scope_t::execute_command(strings_list args, bool at_repl) } strings_list::iterator arg = args.begin(); - string verb = *arg++; + string verb = *arg++; // Look for a precommand first, which is defined as any defined function // whose name starts with "ledger_precmd_". The difference between a @@ -180,8 +180,8 @@ void global_scope_t::execute_command(strings_list args, bool at_repl) // then invoke the command. expr_t::func_t command; - bool is_precommand = false; - bind_scope_t bound_scope(*this, report()); + bool is_precommand = false; + bind_scope_t bound_scope(*this, report()); if (bool(command = look_for_precommand(bound_scope, verb))) is_precommand = true; @@ -206,11 +206,11 @@ void global_scope_t::execute_command(strings_list args, bool at_repl) report().output_stream .initialize(report().HANDLED(output_) ? - optional<path>(path(report().HANDLER(output_).str())) : - optional<path>(), - report().HANDLED(pager_) ? - optional<path>(path(report().HANDLER(pager_).str())) : - optional<path>()); + optional<path>(path(report().HANDLER(output_).str())) : + optional<path>(), + report().HANDLED(pager_) ? + optional<path>(path(report().HANDLER(pager_).str())) : + optional<path>()); // Now that the output stream is initialized, report the options that will // participate in this report, if the user specified --options @@ -316,7 +316,7 @@ option_t<global_scope_t> * global_scope_t::lookup_option(const char * p) } expr_t::ptr_op_t global_scope_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { switch (kind) { case symbol_t::FUNCTION: @@ -334,9 +334,9 @@ expr_t::ptr_op_t global_scope_t::lookup(const symbol_t::kind_t kind, switch (*p) { case 'p': if (is_eq(p, "push")) - return MAKE_FUNCTOR(global_scope_t::push_command); + return MAKE_FUNCTOR(global_scope_t::push_command); else if (is_eq(p, "pop")) - return MAKE_FUNCTOR(global_scope_t::pop_command); + return MAKE_FUNCTOR(global_scope_t::pop_command); break; } } @@ -400,8 +400,8 @@ void global_scope_t::normalize_session_options() #endif // defined(LOGGING_ON) } -expr_t::func_t global_scope_t::look_for_precommand(scope_t& scope, - const string& verb) +expr_t::func_t global_scope_t::look_for_precommand(scope_t& scope, + const string& verb) { if (expr_t::ptr_op_t def = scope.lookup(symbol_t::PRECOMMAND, verb)) return def->as_function(); @@ -410,7 +410,7 @@ expr_t::func_t global_scope_t::look_for_precommand(scope_t& scope, } expr_t::func_t global_scope_t::look_for_command(scope_t& scope, - const string& verb) + const string& verb) { if (expr_t::ptr_op_t def = scope.lookup(symbol_t::COMMAND, verb)) return def->as_function(); @@ -424,7 +424,7 @@ void global_scope_t::visit_man_page() const if (pid < 0) { throw std::logic_error(_("Failed to fork child process")); } - else if (pid == 0) { // child + else if (pid == 0) { // child execlp("man", "man", "1", "ledger", NULL); // We should never, ever reach here @@ -434,7 +434,7 @@ void global_scope_t::visit_man_page() const int status = -1; wait(&status); - exit(0); // parent + exit(0); // parent } void handle_debug_options(int argc, char * argv[]) @@ -442,37 +442,37 @@ void handle_debug_options(int argc, char * argv[]) for (int i = 1; i < argc; i++) { if (argv[i][0] == '-') { if (std::strcmp(argv[i], "--args-only") == 0) { - args_only = true; + args_only = true; } else if (std::strcmp(argv[i], "--verify") == 0) { #if defined(VERIFY_ON) - verify_enabled = true; // global in utils.h + verify_enabled = true; // global in utils.h #endif } else if (std::strcmp(argv[i], "--verbose") == 0 || - std::strcmp(argv[i], "-v") == 0) { + std::strcmp(argv[i], "-v") == 0) { #if defined(LOGGING_ON) - _log_level = LOG_INFO; // global in utils.h + _log_level = LOG_INFO; // global in utils.h #endif } else if (i + 1 < argc && std::strcmp(argv[i], "--debug") == 0) { #if defined(DEBUG_ON) - _log_level = LOG_DEBUG; // global in utils.h - _log_category = argv[i + 1]; // global in utils.h - i++; + _log_level = LOG_DEBUG; // global in utils.h + _log_category = argv[i + 1]; // global in utils.h + i++; #endif } else if (i + 1 < argc && std::strcmp(argv[i], "--trace") == 0) { #if defined(TRACING_ON) - _log_level = LOG_TRACE; // global in utils.h - try { - // global in utils.h - _trace_level = boost::lexical_cast<uint8_t>(argv[i + 1]); - } - catch (const boost::bad_lexical_cast& e) { - throw std::logic_error(_("Argument to --trace must be an integer")); - } - i++; + _log_level = LOG_TRACE; // global in utils.h + try { + // global in utils.h + _trace_level = boost::lexical_cast<uint8_t>(argv[i + 1]); + } + catch (const boost::bad_lexical_cast& e) { + throw std::logic_error(_("Argument to --trace must be an integer")); + } + i++; #endif } } diff --git a/src/global.h b/src/global.h index 05e3bdb7..87f2495a 100644 --- a/src/global.h +++ b/src/global.h @@ -50,16 +50,16 @@ class report_t; class global_scope_t : public noncopyable, public scope_t { shared_ptr<session_t> session_ptr; - ptr_list<report_t> report_stack; + ptr_list<report_t> report_stack; public: global_scope_t(char ** envp); ~global_scope_t(); - void read_init(); - void read_environment_settings(char * envp[]); - strings_list read_command_arguments(scope_t& scope, strings_list args); - void normalize_session_options(); + void read_init(); + void read_environment_settings(char * envp[]); + strings_list read_command_arguments(scope_t& scope, strings_list args); + void normalize_session_options(); expr_t::func_t look_for_precommand(scope_t& scope, const string& verb); expr_t::func_t look_for_command(scope_t& scope, const string& verb); @@ -98,7 +98,7 @@ public: // open output stream at this point. We want it to get popped off as // soon as this command terminate so that the stream is closed cleanly. report_stack.insert(++report_stack.begin(), - new report_t(report_stack.front())); + new report_t(report_stack.front())); return true; } value_t pop_command(call_scope_t&) { @@ -121,7 +121,7 @@ See LICENSE file included with the distribution for details and disclaimer."); option_t<global_scope_t> * lookup_option(const char * p); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); OPTION(global_scope_t, args_only); OPTION(global_scope_t, debug_); @@ -152,7 +152,7 @@ See LICENSE file included with the distribution for details and disclaimer."); OPTION_(global_scope_t, version, DO() { // -v parent->show_version_info(std::cout); - throw int(0); // exit immediately + throw int(0); // exit immediately }); }; diff --git a/src/interactive.cc b/src/interactive.cc index 183a84fd..54c7fd6c 100644 --- a/src/interactive.cc +++ b/src/interactive.cc @@ -39,16 +39,16 @@ void interactive_t::verify_arguments() const { value_t::sequence_t::const_iterator i; - const char * p = spec.c_str(); - const char * label = _("unknown"); - bool wrong_arg = false; - bool dont_skip = false; - bool optional = *p == '&'; - bool exit_loop = *p == '*'; - std::size_t offset = 1; - bool is_seq = args.value().is_sequence(); + const char * p = spec.c_str(); + const char * label = _("unknown"); + bool wrong_arg = false; + bool dont_skip = false; + bool optional = *p == '&'; + bool exit_loop = *p == '*'; + std::size_t offset = 1; + bool is_seq = args.value().is_sequence(); const value_t * next_arg = NULL; - string vlabel; + string vlabel; if (is_seq) { i = args.begin(); @@ -61,45 +61,45 @@ void interactive_t::verify_arguments() const for (; ! wrong_arg && ! exit_loop && *p && next_arg; p++) { DEBUG("interactive.verify", - "Want " << *p << " got: " << next_arg->label()); + "Want " << *p << " got: " << next_arg->label()); wrong_arg = false; switch (*p) { case 'a': label = _("an amount"); wrong_arg = (! next_arg->is_long() && - ! next_arg->is_amount() && - ! next_arg->is_balance()); + ! next_arg->is_amount() && + ! next_arg->is_balance()); break; case 'b': label = _("a boolean"); - wrong_arg = false; // booleans are converted + wrong_arg = false; // booleans are converted break; case 'd': label = _("a date"); wrong_arg = (! next_arg->is_date() && - ! next_arg->is_datetime()); + ! next_arg->is_datetime()); break; case 't': label = _("a date/time"); wrong_arg = (! next_arg->is_date() && - ! next_arg->is_datetime()); + ! next_arg->is_datetime()); break; case 'i': case 'l': label = _("an integer"); if (next_arg->is_long() || - (next_arg->is_amount() && - ! next_arg->as_amount().has_commodity())) { + (next_arg->is_amount() && + ! next_arg->as_amount().has_commodity())) { wrong_arg = false; } else if (next_arg->is_string()) { wrong_arg = false; for (const char * q = next_arg->as_string().c_str(); *q; q++) { - if (! std::isdigit(*q) && *q != '-') { - wrong_arg = true; - break; - } + if (! std::isdigit(*q) && *q != '-') { + wrong_arg = true; + break; + } } } else { @@ -150,14 +150,14 @@ void interactive_t::verify_arguments() const if (! dont_skip) { if (is_seq) { - if (++i != args.end()) { - next_arg = &(*i); - offset++; - } else { - next_arg = NULL; - } + if (++i != args.end()) { + next_arg = &(*i); + offset++; + } else { + next_arg = NULL; + } } else { - next_arg = NULL; + next_arg = NULL; } } dont_skip = false; @@ -170,8 +170,8 @@ void interactive_t::verify_arguments() const if (wrong_arg) { throw_(std::logic_error, - _("Expected %1 for argument %2, but received %3") - << label << offset << vlabel); + _("Expected %1 for argument %2, but received %3") + << label << offset << vlabel); } else if (*p && ! optional && ! next_arg) { throw_(std::logic_error, _("Too few arguments to function")); diff --git a/src/item.cc b/src/item.cc index 6a948ae4..8a056e6c 100644 --- a/src/item.cc +++ b/src/item.cc @@ -58,15 +58,15 @@ bool item_t::has_tag(const string& tag) const } bool item_t::has_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask) const + const optional<mask_t>& value_mask) const { if (metadata) { foreach (const string_map::value_type& data, *metadata) { if (tag_mask.match(data.first)) { - if (! value_mask) - return true; - else if (data.second.first) - return value_mask->match(*data.second.first); + if (! value_mask) + return true; + else if (data.second.first) + return value_mask->match(*data.second.first); } } } @@ -88,14 +88,14 @@ optional<string> item_t::get_tag(const string& tag) const } optional<string> item_t::get_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask) const + const optional<mask_t>& value_mask) const { if (metadata) { foreach (const string_map::value_type& data, *metadata) { if (tag_mask.match(data.first) && - (! value_mask || - (data.second.first && value_mask->match(*data.second.first)))) - return data.second.first; + (! value_mask || + (data.second.first && value_mask->match(*data.second.first)))) + return data.second.first; } } return none; @@ -103,8 +103,8 @@ optional<string> item_t::get_tag(const mask_t& tag_mask, item_t::string_map::iterator item_t::set_tag(const string& tag, - const optional<string>& value, - const bool overwrite_existing) + const optional<string>& value, + const bool overwrite_existing) { assert(! tag.empty()); @@ -112,7 +112,7 @@ item_t::set_tag(const string& tag, metadata = string_map(); DEBUG("item.meta", "Setting tag '" << tag << "' to value '" - << (value ? *value : string("<none>")) << "'"); + << (value ? *value : string("<none>")) << "'"); optional<string> data = value; if (data && data->empty()) @@ -132,22 +132,22 @@ item_t::set_tag(const string& tag, } void item_t::parse_tags(const char * p, bool overwrite_existing, - optional<date_t::year_type> current_year) + optional<date_t::year_type> current_year) { if (const char * b = std::strchr(p, '[')) { if (*(b + 1) != '\0' && - (std::isdigit(*(b + 1)) || *(b + 1) == '=')) { + (std::isdigit(*(b + 1)) || *(b + 1) == '=')) { if (const char * e = std::strchr(p, ']')) { - char buf[256]; - std::strncpy(buf, b + 1, e - b - 1); - buf[e - b - 1] = '\0'; - - if (char * p = std::strchr(buf, '=')) { - *p++ = '\0'; - _date_eff = parse_date(p, current_year); - } - if (buf[0]) - _date = parse_date(buf, current_year); + char buf[256]; + std::strncpy(buf, b + 1, e - b - 1); + buf[e - b - 1] = '\0'; + + if (char * p = std::strchr(buf, '=')) { + *p++ = '\0'; + _date_eff = parse_date(p, current_year); + } + if (buf[0]) + _date = parse_date(buf, current_year); } } } @@ -166,16 +166,16 @@ void item_t::parse_tags(const char * p, bool overwrite_existing, const string::size_type len = std::strlen(q); if (! tag.empty()) { string_map::iterator i = set_tag(tag, string(p + (q - buf.get())), - overwrite_existing); + overwrite_existing); (*i).second.second = true; break; } else if (q[0] == ':' && q[len - 1] == ':') { // a series of tags for (char * r = std::strtok(q + 1, ":"); - r; - r = std::strtok(NULL, ":")) { - string_map::iterator i = set_tag(r, none, overwrite_existing); - (*i).second.second = true; + r; + r = std::strtok(NULL, ":")) { + string_map::iterator i = set_tag(r, none, overwrite_existing); + (*i).second.second = true; } } else if (q[len - 1] == ':') { // a metadata setting @@ -185,7 +185,7 @@ void item_t::parse_tags(const char * p, bool overwrite_existing, } void item_t::append_note(const char * p, bool overwrite_existing, - optional<date_t::year_type> current_year) + optional<date_t::year_type> current_year) { if (note) { *note += '\n'; @@ -235,21 +235,21 @@ namespace { if (args.size() == 1) { if (args[0].is_string()) - return item.has_tag(args[0].as_string()); + return item.has_tag(args[0].as_string()); else if (args[0].is_mask()) - return item.has_tag(args[0].as_mask()); + return item.has_tag(args[0].as_mask()); else - throw_(std::runtime_error, - _("Expected string or mask for argument 1, but received %1") - << args[0].label()); + throw_(std::runtime_error, + _("Expected string or mask for argument 1, but received %1") + << args[0].label()); } else if (args.size() == 2) { if (args[0].is_mask() && args[1].is_mask()) - return item.has_tag(args[0].to_mask(), args[1].to_mask()); + return item.has_tag(args[0].to_mask(), args[1].to_mask()); else - throw_(std::runtime_error, - _("Expected masks for arguments 1 and 2, but received %1 and %2") - << args[0].label() << args[1].label()); + throw_(std::runtime_error, + _("Expected masks for arguments 1 and 2, but received %1 and %2") + << args[0].label() << args[1].label()); } else if (args.size() == 0) { throw_(std::runtime_error, _("Too few arguments to function")); @@ -267,21 +267,21 @@ namespace { if (args.size() == 1) { if (args[0].is_string()) - str = item.get_tag(args[0].as_string()); + str = item.get_tag(args[0].as_string()); else if (args[0].is_mask()) - str = item.get_tag(args[0].as_mask()); + str = item.get_tag(args[0].as_mask()); else - throw_(std::runtime_error, - _("Expected string or mask for argument 1, but received %1") - << args[0].label()); + throw_(std::runtime_error, + _("Expected string or mask for argument 1, but received %1") + << args[0].label()); } else if (args.size() == 2) { if (args[0].is_mask() && args[1].is_mask()) - str = item.get_tag(args[0].to_mask(), args[1].to_mask()); + str = item.get_tag(args[0].to_mask(), args[1].to_mask()); else - throw_(std::runtime_error, - _("Expected masks for arguments 1 and 2, but received %1 and %2") - << args[0].label() << args[1].label()); + throw_(std::runtime_error, + _("Expected masks for arguments 1 and 2, but received %1 and %2") + << args[0].label() << args[1].label()); } else if (args.size() == 0) { throw_(std::runtime_error, _("Too few arguments to function")); @@ -355,13 +355,13 @@ value_t get_comment(item_t& item) bool need_separator = false; for (const char * p = item.note->c_str(); *p; p++) { if (*p == '\n') { - need_separator = true; + need_separator = true; } else { - if (need_separator) { - buf << "\n ;"; - need_separator = false; - } - buf << *p; + if (need_separator) { + buf << "\n ;"; + need_separator = false; + } + buf << *p; } } return string_value(buf.str()); @@ -369,7 +369,7 @@ value_t get_comment(item_t& item) } expr_t::ptr_op_t item_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (kind != symbol_t::FUNCTION) return NULL; @@ -502,7 +502,7 @@ bool item_t::valid() const void print_item(std::ostream& out, const item_t& item, const string& prefix) { out << source_context(item.pos->pathname, item.pos->beg_pos, - item.pos->end_pos, prefix); + item.pos->end_pos, prefix); } string item_context(const item_t& item, const string& desc) @@ -528,7 +528,7 @@ string item_context(const item_t& item, const string& desc) if (item.pos->beg_line != item.pos->end_line) out << _(", lines ") << item.pos->beg_line << "-" - << item.pos->end_line << ":\n"; + << item.pos->end_line << ":\n"; else out << _(", line ") << item.pos->beg_line << ":\n"; @@ -50,10 +50,10 @@ struct position_t { path pathname; istream_pos_type beg_pos; - std::size_t beg_line; + std::size_t beg_line; istream_pos_type end_pos; - std::size_t end_line; - std::size_t sequence; + std::size_t end_line; + std::size_t sequence; position_t() : beg_pos(0), beg_line(0), end_pos(0), end_line(0), sequence(0) { @@ -100,16 +100,16 @@ private: class item_t : public supports_flags<uint_least16_t>, public scope_t { public: -#define ITEM_NORMAL 0x00 // no flags at all, a basic posting -#define ITEM_GENERATED 0x01 // posting was not found in a journal -#define ITEM_TEMP 0x02 // posting is a managed temporary +#define ITEM_NORMAL 0x00 // no flags at all, a basic posting +#define ITEM_GENERATED 0x01 // posting was not found in a journal +#define ITEM_TEMP 0x02 // posting is a managed temporary enum state_t { UNCLEARED = 0, CLEARED, PENDING }; typedef std::pair<optional<string>, bool> tag_data_t; - typedef std::map<string, tag_data_t> string_map; + typedef std::map<string, tag_data_t> string_map; - state_t _state; + state_t _state; optional<date_t> _date; optional<date_t> _date_eff; optional<string> note; @@ -151,21 +151,21 @@ public: virtual bool has_tag(const string& tag) const; virtual bool has_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask = none) const; + const optional<mask_t>& value_mask = none) const; virtual optional<string> get_tag(const string& tag) const; virtual optional<string> get_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask = none) const; + const optional<mask_t>& value_mask = none) const; virtual string_map::iterator - set_tag(const string& tag, - const optional<string>& value = none, - const bool overwrite_existing = true); + set_tag(const string& tag, + const optional<string>& value = none, + const bool overwrite_existing = true); virtual void parse_tags(const char * p, bool overwrite_existing = true, - optional<date_t::year_type> current_year = none); + optional<date_t::year_type> current_year = none); virtual void append_note(const char * p, bool overwrite_existing = true, - optional<date_t::year_type> current_year = none); + optional<date_t::year_type> current_year = none); static bool use_effective_date; @@ -173,7 +173,7 @@ public: assert(_date); if (use_effective_date) if (optional<date_t> effective = effective_date()) - return *effective; + return *effective; return *_date; } virtual date_t actual_date() const { @@ -192,7 +192,7 @@ public: } virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); bool valid() const; @@ -217,9 +217,9 @@ private: }; value_t get_comment(item_t& item); -void print_item(std::ostream& out, const item_t& item, - const string& prefix = ""); -string item_context(const item_t& item, const string& desc); +void print_item(std::ostream& out, const item_t& item, + const string& prefix = ""); +string item_context(const item_t& item, const string& desc); } // namespace ledger diff --git a/src/iterators.cc b/src/iterators.cc index ade1d4b3..b63a10e9 100644 --- a/src/iterators.cc +++ b/src/iterators.cc @@ -91,47 +91,47 @@ void posts_commodities_iterator::reset(journal_t& journal) foreach (commodity_t * comm, commodities) { if (optional<commodity_t::varied_history_t&> history = - comm->varied_history()) { + comm->varied_history()) { account_t * account = journal.master->find_account(comm->symbol()); foreach (commodity_t::history_by_commodity_map::value_type& pair, - history->histories) { - foreach (commodity_t::history_map::value_type& hpair, - pair.second.prices) { - xact_t * xact; - string symbol = hpair.second.commodity().symbol(); - - std::map<string, xact_t *>::iterator i = - xacts_by_commodity.find(symbol); - if (i != xacts_by_commodity.end()) { - xact = (*i).second; - } else { - xact = &temps.create_xact(); - xact_temps.push_back(xact); - xact->payee = symbol; - xact->_date = hpair.first.date(); - xacts_by_commodity.insert - (std::pair<string, xact_t *>(symbol, xact)); - } - - bool post_already_exists = false; - - foreach (post_t * post, xact->posts) { - if (post->_date == hpair.first.date() && - post->amount == hpair.second) { - post_already_exists = true; - break; - } - } - - if (! post_already_exists) { - post_t& temp = temps.create_post(*xact, account); - temp._date = hpair.first.date(); - temp.amount = hpair.second; - - temp.xdata().datetime = hpair.first; - } - } + history->histories) { + foreach (commodity_t::history_map::value_type& hpair, + pair.second.prices) { + xact_t * xact; + string symbol = hpair.second.commodity().symbol(); + + std::map<string, xact_t *>::iterator i = + xacts_by_commodity.find(symbol); + if (i != xacts_by_commodity.end()) { + xact = (*i).second; + } else { + xact = &temps.create_xact(); + xact_temps.push_back(xact); + xact->payee = symbol; + xact->_date = hpair.first.date(); + xacts_by_commodity.insert + (std::pair<string, xact_t *>(symbol, xact)); + } + + bool post_already_exists = false; + + foreach (post_t * post, xact->posts) { + if (post->_date == hpair.first.date() && + post->amount == hpair.second) { + post_already_exists = true; + break; + } + } + + if (! post_already_exists) { + post_t& temp = temps.create_post(*xact, account); + temp._date = hpair.first.date(); + temp.amount = hpair.second; + + temp.xdata().datetime = hpair.first; + } + } } } } @@ -162,7 +162,7 @@ post_t * posts_commodities_iterator::operator()() account_t * basic_accounts_iterator::operator()() { while (! accounts_i.empty() && - accounts_i.back() == accounts_end.back()) { + accounts_i.back() == accounts_end.back()) { accounts_i.pop_back(); accounts_end.pop_back(); } @@ -187,14 +187,14 @@ void sorted_accounts_iterator::push_back(account_t& account) push_all(account, accounts_list.back()); std::stable_sort(accounts_list.back().begin(), - accounts_list.back().end(), - compare_items<account_t>(sort_cmp)); + accounts_list.back().end(), + compare_items<account_t>(sort_cmp)); #if defined(DEBUG_ON) if (SHOW_DEBUG("accounts.sorted")) { foreach (account_t * account, accounts_list.back()) - DEBUG("accounts.sorted", - "Account (flat): " << account->fullname()); + DEBUG("accounts.sorted", + "Account (flat): " << account->fullname()); } #endif } else { @@ -206,7 +206,7 @@ void sorted_accounts_iterator::push_back(account_t& account) } void sorted_accounts_iterator::push_all(account_t& account, - accounts_deque_t& deque) + accounts_deque_t& deque) { foreach (accounts_map::value_type& pair, account.accounts) { deque.push_back(pair.second); @@ -215,13 +215,13 @@ void sorted_accounts_iterator::push_all(account_t& account, } void sorted_accounts_iterator::sort_accounts(account_t& account, - accounts_deque_t& deque) + accounts_deque_t& deque) { foreach (accounts_map::value_type& pair, account.accounts) deque.push_back(pair.second); std::stable_sort(deque.begin(), deque.end(), - compare_items<account_t>(sort_cmp)); + compare_items<account_t>(sort_cmp)); #if defined(DEBUG_ON) if (SHOW_DEBUG("accounts.sorted")) { @@ -234,7 +234,7 @@ void sorted_accounts_iterator::sort_accounts(account_t& account, account_t * sorted_accounts_iterator::operator()() { while (! sorted_accounts_i.empty() && - sorted_accounts_i.back() == sorted_accounts_end.back()) { + sorted_accounts_i.back() == sorted_accounts_end.back()) { sorted_accounts_i.pop_back(); sorted_accounts_end.pop_back(); assert(! accounts_list.empty()); diff --git a/src/iterators.h b/src/iterators.h index 5e9f5fbe..5113d3b2 100644 --- a/src/iterators.h +++ b/src/iterators.h @@ -142,8 +142,8 @@ class posts_commodities_iterator : public posts_iterator { protected: journal_posts_iterator journal_posts; - xacts_iterator xacts; - xact_posts_iterator posts; + xacts_iterator xacts; + xact_posts_iterator posts; temporaries_t temps; xacts_list xact_temps; @@ -203,13 +203,13 @@ class sorted_accounts_iterator : public accounts_iterator typedef std::deque<account_t *> accounts_deque_t; - std::list<accounts_deque_t> accounts_list; + std::list<accounts_deque_t> accounts_list; std::list<accounts_deque_t::const_iterator> sorted_accounts_i; std::list<accounts_deque_t::const_iterator> sorted_accounts_end; public: sorted_accounts_iterator(account_t& account, - const expr_t& _sort_cmp, bool _flatten_all) + const expr_t& _sort_cmp, bool _flatten_all) : sort_cmp(_sort_cmp), flatten_all(_flatten_all) { TRACE_CTOR(sorted_accounts_iterator, "const expr_t&, bool, account_t&"); push_back(account); diff --git a/src/journal.cc b/src/journal.cc index 158fac42..fd6d3eac 100644 --- a/src/journal.cc +++ b/src/journal.cc @@ -145,9 +145,9 @@ bool journal_t::remove_xact(xact_t * xact) } std::size_t journal_t::read(std::istream& in, - const path& pathname, - account_t * master_alt, - scope_t * scope) + const path& pathname, + account_t * master_alt, + scope_t * scope) { std::size_t count = 0; try { @@ -156,13 +156,13 @@ std::size_t journal_t::read(std::istream& in, if (! scope) throw_(std::runtime_error, - _("No default scope in which to read journal file '%1'") - << pathname); + _("No default scope in which to read journal file '%1'") + << pathname); value_t strict = expr_t("strict").calc(*scope); count = parse(in, *scope, master_alt ? master_alt : master, - &pathname, strict.to_boolean()); + &pathname, strict.to_boolean()); } catch (...) { clear_xdata(); @@ -178,14 +178,14 @@ std::size_t journal_t::read(std::istream& in, } std::size_t journal_t::read(const path& pathname, - account_t * master, - scope_t * scope) + account_t * master, + scope_t * scope) { path filename = resolve_path(pathname); if (! exists(filename)) throw_(std::runtime_error, - _("Cannot read journal file '%1'") << filename); + _("Cannot read journal file '%1'") << filename); ifstream stream(filename); std::size_t count = read(stream, filename, master, scope); diff --git a/src/journal.h b/src/journal.h index a407c02c..ca6b6e4f 100644 --- a/src/journal.h +++ b/src/journal.h @@ -55,7 +55,7 @@ class period_xact_t; class account_t; class scope_t; -typedef std::list<xact_t *> xacts_list; +typedef std::list<xact_t *> xacts_list; typedef std::list<auto_xact_t *> auto_xacts_list; typedef std::list<period_xact_t *> period_xacts_list; @@ -70,9 +70,9 @@ public: struct fileinfo_t { optional<path> filename; - uintmax_t size; - datetime_t modtime; - bool from_stream; + uintmax_t size; + datetime_t modtime; + bool from_stream; fileinfo_t() : size(0), from_stream(true) { TRACE_CTOR(journal_t::fileinfo_t, ""); @@ -85,7 +85,7 @@ public: } fileinfo_t(const fileinfo_t& info) : filename(info.filename), size(info.size), - modtime(info.modtime), from_stream(info.from_stream) + modtime(info.modtime), from_stream(info.from_stream) { TRACE_CTOR(journal_t::fileinfo_t, "copy"); } @@ -109,11 +109,11 @@ public: #endif // HAVE_BOOST_SERIALIZATION }; - account_t * master; - account_t * bucket; - xacts_list xacts; - auto_xacts_list auto_xacts; - period_xacts_list period_xacts; + account_t * master; + account_t * bucket; + xacts_list xacts; + auto_xacts_list auto_xacts; + period_xacts_list period_xacts; std::list<fileinfo_t> sources; payee_mappings_t payee_mappings; account_mappings_t account_mappings; @@ -135,8 +135,8 @@ public: // These four methods are delegated to the current session, since all // accounts processed are gathered together at the session level. - void add_account(account_t * acct); - bool remove_account(account_t * acct); + void add_account(account_t * acct); + bool remove_account(account_t * acct); account_t * find_account(const string& name, bool auto_create = true); account_t * find_account_re(const string& regexp); @@ -164,18 +164,18 @@ public: } std::size_t read(std::istream& in, - const path& pathname, - account_t * master = NULL, - scope_t * scope = NULL); - std::size_t read(const path& pathname, - account_t * master = NULL, - scope_t * scope = NULL); + const path& pathname, + account_t * master = NULL, + scope_t * scope = NULL); + std::size_t read(const path& pathname, + account_t * master = NULL, + scope_t * scope = NULL); std::size_t parse(std::istream& in, - scope_t& session_scope, - account_t * master = NULL, - const path * original_file = NULL, - bool strict = false); + scope_t& session_scope, + account_t * master = NULL, + const path * original_file = NULL, + bool strict = false); bool has_xdata(); void clear_xdata(); diff --git a/src/lookup.cc b/src/lookup.cc index 40b6c185..221397ca 100644 --- a/src/lookup.cc +++ b/src/lookup.cc @@ -43,7 +43,7 @@ namespace { struct score_sorter { bool operator()(const score_entry_t& left, - const score_entry_t& right) const { + const score_entry_t& right) const { return left.second > right.second; } }; @@ -53,7 +53,7 @@ namespace { struct usage_sorter { bool operator()(const account_use_pair& left, - const account_use_pair& right) const { + const account_use_pair& right) const { return left.second > right.second; } }; @@ -61,8 +61,8 @@ namespace { std::pair<xact_t *, account_t *> lookup_probable_account(const string& ident, - xacts_iterator& iter_func, - account_t * ref_account) + xacts_iterator& iter_func, + account_t * ref_account) { scorecard_t scores; @@ -76,11 +76,11 @@ lookup_probable_account(const string& ident, #endif DEBUG("lookup.account", - "Looking up identifier '" << lowered_ident.extract() << "'"); + "Looking up identifier '" << lowered_ident.extract() << "'"); #if defined(DEBUG_ON) if (ref_account != NULL) DEBUG("lookup.account", - " with reference account: " << ref_account->fullname()); + " with reference account: " << ref_account->fullname()); #endif while (xact_t * xact = iter_func()) { @@ -109,17 +109,17 @@ lookup_probable_account(const string& ident, DEBUG("lookup", "Considering payee: " << value_key.extract()); - std::size_t index = 0; - std::size_t last_match_pos = unistring::npos; - int bonus = 0; - int score = 0; - std::size_t pos; + std::size_t index = 0; + std::size_t last_match_pos = unistring::npos; + int bonus = 0; + int score = 0; + std::size_t pos; char_positions_map positions; // Walk each letter in the source identifier foreach (const uint32_t& ch, lowered_ident.utf32chars) { - int addend = 0; - bool added_bonus = false; + int addend = 0; + bool added_bonus = false; std::size_t value_len = value_key.length(); pos = value_key.find(ch); @@ -131,76 +131,76 @@ lookup_probable_account(const string& ident, char_positions_map::iterator pi = positions.find(ch); while (pi != positions.end() && - pos != unistring::npos && pos <= (*pi).second && - (*pi).second + 1 < value_len) - pos = value_key.find(ch, (*pi).second + 1); + pos != unistring::npos && pos <= (*pi).second && + (*pi).second + 1 < value_len) + pos = value_key.find(ch, (*pi).second + 1); if (pos != unistring::npos) { - if (pi != positions.end()) - (*pi).second = pos; - else - positions.insert(char_positions_map::value_type(ch, pos)); - - // If it occurs in the same order as the source identifier -- that is, - // without intervening letters to break the pattern -- it's worth 10 - // points. Plus, an extra point is added for every letter in chains - // of 3 or more. - - if (last_match_pos == unistring::npos ? - index == 0 && pos == 0 : pos == last_match_pos + 1) { - DEBUG("lookup", - " char " << index << " in-sequence match with bonus " << bonus); - addend += 10; - if (bonus > 2) - addend += bonus - 2; - bonus++; - added_bonus = true; - - last_match_pos = pos; - } - - // If it occurs in the same general sequence as the source identifier, - // it's worth 5 points, plus an extra point if it's within the next 3 - // characters, and an extra point if it's preceded by a non-alphabetic - // character. - // - // If the letter occurs at all in the target identifier, it's worth 1 - // point, plus an extra point if it's within 3 characters, and an - // extra point if it's preceded by a non-alphabetic character. - - else { - bool in_order_match = (last_match_pos != unistring::npos && - pos > last_match_pos); - DEBUG("lookup", " char " << index << " " << - (in_order_match ? "in-order" : "out-of-order") - << " match" << (in_order_match && pos - index < 3 ? - " with proximity bonus of 1" : "")); - - if (pos < index) - addend += 1; - else - addend += 5; - - if (in_order_match && pos - index < 3) - addend++; + if (pi != positions.end()) + (*pi).second = pos; + else + positions.insert(char_positions_map::value_type(ch, pos)); + + // If it occurs in the same order as the source identifier -- that is, + // without intervening letters to break the pattern -- it's worth 10 + // points. Plus, an extra point is added for every letter in chains + // of 3 or more. + + if (last_match_pos == unistring::npos ? + index == 0 && pos == 0 : pos == last_match_pos + 1) { + DEBUG("lookup", + " char " << index << " in-sequence match with bonus " << bonus); + addend += 10; + if (bonus > 2) + addend += bonus - 2; + bonus++; + added_bonus = true; + + last_match_pos = pos; + } + + // If it occurs in the same general sequence as the source identifier, + // it's worth 5 points, plus an extra point if it's within the next 3 + // characters, and an extra point if it's preceded by a non-alphabetic + // character. + // + // If the letter occurs at all in the target identifier, it's worth 1 + // point, plus an extra point if it's within 3 characters, and an + // extra point if it's preceded by a non-alphabetic character. + + else { + bool in_order_match = (last_match_pos != unistring::npos && + pos > last_match_pos); + DEBUG("lookup", " char " << index << " " << + (in_order_match ? "in-order" : "out-of-order") + << " match" << (in_order_match && pos - index < 3 ? + " with proximity bonus of 1" : "")); + + if (pos < index) + addend += 1; + else + addend += 5; + + if (in_order_match && pos - index < 3) + addend++; #if !defined(HAVE_BOOST_REGEX_UNICODE) - if (pos == 0 || (pos > 0 && !std::isalnum(value_key[pos - 1]))) - addend++; + if (pos == 0 || (pos > 0 && !std::isalnum(value_key[pos - 1]))) + addend++; #else - // jww (2010-03-07): Not yet implemented + // jww (2010-03-07): Not yet implemented #endif - last_match_pos = pos; - } + last_match_pos = pos; + } // If the letter does not appear at all, decrease the score by 1 } else { - last_match_pos = unistring::npos; + last_match_pos = unistring::npos; - DEBUG("lookup", " char " << index << " does not match"); - addend--; + DEBUG("lookup", " char " << index << " does not match"); + addend--; } // Finally, decay what is to be added to the score based on its position @@ -211,9 +211,9 @@ lookup_probable_account(const string& ident, // divisor for the addend. if ((int(index / 5) + 1) > 1) { - DEBUG("lookup", - " discounting the addend by / " << (int(index / 5) + 1)); - addend = int(double(addend) / (int(index / 5) + 1)); + DEBUG("lookup", + " discounting the addend by / " << (int(index / 5) + 1)); + addend = int(double(addend) / (int(index / 5) + 1)); } DEBUG("lookup", " final addend is " << addend); @@ -221,7 +221,7 @@ lookup_probable_account(const string& ident, DEBUG("lookup", " score is " << score); if (! added_bonus) - bonus = 0; + bonus = 0; index++; } @@ -238,26 +238,26 @@ lookup_probable_account(const string& ident, std::stable_sort(scores.begin(), scores.end(), score_sorter()); - scorecard_t::iterator si = scores.begin(); - int decay = 0; - xact_t * best_xact = si != scores.end() ? (*si).first : NULL; - account_use_map account_usage; + scorecard_t::iterator si = scores.begin(); + int decay = 0; + xact_t * best_xact = si != scores.end() ? (*si).first : NULL; + account_use_map account_usage; for (int i = 0; i < 5 && si != scores.end(); i++, si++) { DEBUG("lookup.account", - "Payee: " << std::setw(5) << std::right << (*si).second << - " - " << (*si).first->payee); + "Payee: " << std::setw(5) << std::right << (*si).second << + " - " << (*si).first->payee); foreach (post_t * post, (*si).first->posts) { if (! post->has_flags(ITEM_TEMP | ITEM_GENERATED) && - post->account != ref_account && - ! post->account->has_flags(ACCOUNT_TEMP | ACCOUNT_GENERATED)) { - account_use_map::iterator x = account_usage.find(post->account); - if (x == account_usage.end()) - account_usage.insert(account_use_pair(post->account, - ((*si).second - decay))); - else - (*x).second += ((*si).second - decay); + post->account != ref_account && + ! post->account->has_flags(ACCOUNT_TEMP | ACCOUNT_GENERATED)) { + account_use_map::iterator x = account_usage.find(post->account); + if (x == account_usage.end()) + account_usage.insert(account_use_pair(post->account, + ((*si).second - decay))); + else + (*x).second += ((*si).second - decay); } decay++; } @@ -267,14 +267,14 @@ lookup_probable_account(const string& ident, #if defined(DEBUG_ON) if (SHOW_DEBUG("lookup.account")) { foreach (const account_use_pair& value, account_usage) { - DEBUG("lookup.account", - "Account: " << value.second << " - " << value.first->fullname()); + DEBUG("lookup.account", + "Account: " << value.second << " - " << value.first->fullname()); } } #endif return std::pair<xact_t *, account_t *> (best_xact, (*std::max_element(account_usage.begin(), account_usage.end(), - usage_sorter())).first); + usage_sorter())).first); } else { return std::pair<xact_t *, account_t *>(best_xact, NULL); } diff --git a/src/lookup.h b/src/lookup.h index 53cb5837..7776be80 100644 --- a/src/lookup.h +++ b/src/lookup.h @@ -48,8 +48,8 @@ namespace ledger { std::pair<xact_t *, account_t *> lookup_probable_account(const string& ident, - xacts_iterator& iter_func, - account_t * ref_account = NULL); + xacts_iterator& iter_func, + account_t * ref_account = NULL); } // namespace ledger diff --git a/src/main.cc b/src/main.cc index 23593533..e0da3a25 100644 --- a/src/main.cc +++ b/src/main.cc @@ -31,8 +31,8 @@ #include <system.hh> -#include "global.h" // This is where the meat of main() is, which - // was moved there for the sake of clarity here +#include "global.h" // This is where the meat of main() is, which + // was moved there for the sake of clarity here #include "session.h" using namespace ledger; @@ -103,13 +103,13 @@ int main(int argc, char * argv[], char * envp[]) ifstream in(global_scope->HANDLER(script_).str()); while (status == 0 && ! in.eof()) { - char line[1024]; - in.getline(line, 1023); + char line[1024]; + in.getline(line, 1023); - char * p = skip_ws(line); - if (*p && *p != '#') - status = global_scope->execute_command_wrapper(split_arguments(p), - true); + char * p = skip_ws(line); + if (*p && *p != '#') + status = global_scope->execute_command_wrapper(split_arguments(p), + true); } } else if (! args.empty()) { @@ -133,53 +133,53 @@ int main(int argc, char * argv[], char * envp[]) #endif while (char * p = readline(global_scope->prompt_string())) { - char * expansion = NULL; - int result; - - result = history_expand(skip_ws(p), &expansion); - - if (result < 0 || result == 2) { - if (expansion) - std::free(expansion); - std::free(p); - throw_(std::logic_error, - _("Failed to expand history reference '%1'") << p); - } - else if (expansion) { - add_history(expansion); - } + char * expansion = NULL; + int result; + + result = history_expand(skip_ws(p), &expansion); + + if (result < 0 || result == 2) { + if (expansion) + std::free(expansion); + std::free(p); + throw_(std::logic_error, + _("Failed to expand history reference '%1'") << p); + } + else if (expansion) { + add_history(expansion); + } #else // HAVE_LIBEDIT while (! std::cin.eof()) { - std::cout << global_scope->prompt_string(); - char line[1024]; - std::cin.getline(line, 1023); + std::cout << global_scope->prompt_string(); + char line[1024]; + std::cin.getline(line, 1023); - char * p = skip_ws(line); + char * p = skip_ws(line); #endif // HAVE_LIBEDIT - check_for_signal(); + check_for_signal(); - if (*p && *p != '#') { - if (std::strncmp(p, "quit", 4) == 0) - exit_loop = true; - else - global_scope->execute_command_wrapper(split_arguments(p), true); - } + if (*p && *p != '#') { + if (std::strncmp(p, "quit", 4) == 0) + exit_loop = true; + else + global_scope->execute_command_wrapper(split_arguments(p), true); + } #ifdef HAVE_LIBEDIT - if (expansion) - std::free(expansion); - std::free(p); + if (expansion) + std::free(expansion); + std::free(p); #endif - if (exit_loop) - break; + if (exit_loop) + break; } - status = 0; // report success + status = 0; // report success } } catch (const std::exception& err) { @@ -187,11 +187,11 @@ int main(int argc, char * argv[], char * envp[]) global_scope->report_error(err); else std::cerr << "Exception during initialization: " << err.what() - << std::endl; + << std::endl; } catch (int _status) { - status = _status; // used for a "quick" exit, and is used only - // if help text (such as --help) was displayed + status = _status; // used for a "quick" exit, and is used only + // if help text (such as --help) was displayed } // If memory verification is being performed (which can be very slow), clean diff --git a/src/mask.cc b/src/mask.cc index cd516fe2..52907cfe 100644 --- a/src/mask.cc +++ b/src/mask.cc @@ -66,17 +66,17 @@ mask_t& mask_t::assign_glob(const string& pat) break; case '[': while (i < len && pat[i] != ']') - re_pat += pat[i++]; + re_pat += pat[i++]; if (i < len) - re_pat += pat[i]; + re_pat += pat[i]; break; case '\\': if (i + 1 < len) { - re_pat += pat[++i]; - break; + re_pat += pat[++i]; + break; } else { - // fallthrough... + // fallthrough... } default: re_pat += pat[i]; @@ -85,13 +85,13 @@ public: bool match(const string& text) const { #if defined(HAVE_BOOST_REGEX_UNICODE) DEBUG("mask.match", - "Matching: \"" << text << "\" =~ /" << str() << "/ = " - << (boost::u32regex_search(text, expr) ? "true" : "false")); + "Matching: \"" << text << "\" =~ /" << str() << "/ = " + << (boost::u32regex_search(text, expr) ? "true" : "false")); return boost::u32regex_search(text, expr); #else DEBUG("mask.match", - "Matching: \"" << text << "\" =~ /" << str() << "/ = " - << (boost::regex_search(text, expr) ? "true" : "false")); + "Matching: \"" << text << "\" =~ /" << str() << "/ = " + << (boost::regex_search(text, expr) ? "true" : "false")); return boost::regex_search(text, expr); #endif } @@ -107,7 +107,7 @@ public: unistring ustr; std::basic_string<UChar32> expr_str = expr.str(); std::copy(expr_str.begin(), expr_str.end(), - std::back_inserter(ustr.utf32chars)); + std::back_inserter(ustr.utf32chars)); return ustr.extract(); #else return expr.str(); @@ -40,7 +40,7 @@ namespace ledger { namespace { value_t split_cons_expr(expr_t::ptr_op_t op, scope_t& scope, - std::vector<expr_t>& exprs) + std::vector<expr_t>& exprs) { value_t seq; @@ -50,16 +50,16 @@ namespace { expr_t::ptr_op_t next = op->right(); while (next) { - expr_t::ptr_op_t value_op; - if (next->kind == expr_t::op_t::O_CONS) { - value_op = next->left(); - next = next->right(); - } else { - value_op = next; - next = NULL; - } - exprs.push_back(expr_t(value_op, &scope)); - seq.push_back(value_t(exprs.back())); + expr_t::ptr_op_t value_op; + if (next->kind == expr_t::op_t::O_CONS) { + value_op = next->left(); + next = next->right(); + } else { + value_op = next; + next = NULL; + } + exprs.push_back(expr_t(value_op, &scope)); + seq.push_back(value_t(exprs.back())); } } else { exprs.push_back(expr_t(op, &scope)); @@ -80,8 +80,8 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth) // not be found there. #if defined(DEBUG_ON) if (SHOW_DEBUG("expr.compile")) { - DEBUG("expr.compile", "Found definition:"); - def->dump(*_log_stream, 0); + DEBUG("expr.compile", "Found definition:"); + def->dump(*_log_stream, 0); } #endif // defined(DEBUG_ON) return copy(def); @@ -102,9 +102,9 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth) break; case O_CALL: if (left()->left()->is_ident()) - scope.define(symbol_t::FUNCTION, left()->left()->as_ident(), this); + scope.define(symbol_t::FUNCTION, left()->left()->as_ident(), this); else - throw_(compile_error, _("Invalid function definition")); + throw_(compile_error, _("Invalid function definition")); break; default: throw_(compile_error, _("Invalid function definition")); @@ -114,8 +114,8 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth) ptr_op_t lhs(left()->compile(scope, depth)); ptr_op_t rhs(kind > UNARY_OPERATORS && has_right() ? - (kind == O_LOOKUP ? right() : - right()->compile(scope, depth)) : NULL); + (kind == O_LOOKUP ? right() : + right()->compile(scope, depth)) : NULL); if (lhs == left() && (! rhs || rhs == right())) return this; @@ -170,31 +170,31 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) case O_DEFINE: { call_scope_t& call_args(downcast<call_scope_t>(scope)); - std::size_t args_count = call_args.size(); - std::size_t args_index = 0; + std::size_t args_count = call_args.size(); + std::size_t args_index = 0; assert(left()->kind == O_CALL); for (ptr_op_t sym = left()->right(); - sym; - sym = sym->has_right() ? sym->right() : NULL) { + sym; + sym = sym->has_right() ? sym->right() : NULL) { ptr_op_t varname = sym; if (sym->kind == O_CONS) - varname = sym->left(); + varname = sym->left(); if (! varname->is_ident()) - throw_(calc_error, _("Invalid function definition")); + throw_(calc_error, _("Invalid function definition")); else if (args_index == args_count) - scope.define(symbol_t::FUNCTION, varname->as_ident(), - wrap_value(false)); + scope.define(symbol_t::FUNCTION, varname->as_ident(), + wrap_value(false)); else - scope.define(symbol_t::FUNCTION, varname->as_ident(), - wrap_value(call_args[args_index++])); + scope.define(symbol_t::FUNCTION, varname->as_ident(), + wrap_value(call_args[args_index++])); } if (args_index < args_count) throw_(calc_error, - _("Too many arguments in function call (saw %1)") << args_count); + _("Too many arguments in function call (saw %1)") << args_count); result = right()->calc(scope, locus, depth + 1); break; @@ -203,24 +203,24 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) case O_LOOKUP: if (value_t obj = left()->calc(scope, locus, depth + 1)) { if (obj.is_scope()) { - if (obj.as_scope() == NULL) { - throw_(calc_error, _("Left operand of . operator is NULL")); - } else { - scope_t& objscope(*obj.as_scope()); - if (ptr_op_t member = - objscope.lookup(symbol_t::FUNCTION, right()->as_ident())) { - result = member->calc(objscope, NULL, depth + 1); - break; - } - } + if (obj.as_scope() == NULL) { + throw_(calc_error, _("Left operand of . operator is NULL")); + } else { + scope_t& objscope(*obj.as_scope()); + if (ptr_op_t member = + objscope.lookup(symbol_t::FUNCTION, right()->as_ident())) { + result = member->calc(objscope, NULL, depth + 1); + break; + } + } } } if (right()->kind != IDENT) throw_(calc_error, - _("Right operand of . operator must be an identifier")); + _("Right operand of . operator must be an identifier")); else throw_(calc_error, - _("Failed to lookup member '%1'") << right()->as_ident()); + _("Failed to lookup member '%1'") << right()->as_ident()); break; case O_CALL: @@ -232,13 +232,13 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) if (has_right()) { if (kind == O_CALL) { - call_args.set_args(right()->calc(scope, locus, depth + 1)); + call_args.set_args(right()->calc(scope, locus, depth + 1)); } else { - // macros defer calculation to the callee - args_expr = std::vector<expr_t>(); - call_args.set_args(split_cons_expr(right()->kind == O_SEQ ? - right()->left() : right(), - scope, *args_expr)); + // macros defer calculation to the callee + args_expr = std::vector<expr_t>(); + call_args.set_args(split_cons_expr(right()->kind == O_SEQ ? + right()->left() : right(), + scope, *args_expr)); } } @@ -258,45 +258,45 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) case O_MATCH: result = (right()->calc(scope, locus, depth + 1).as_mask() - .match(left()->calc(scope, locus, depth + 1).to_string())); + .match(left()->calc(scope, locus, depth + 1).to_string())); break; case O_EQ: result = (left()->calc(scope, locus, depth + 1) == - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_LT: result = (left()->calc(scope, locus, depth + 1) < - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_LTE: result = (left()->calc(scope, locus, depth + 1) <= - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_GT: result = (left()->calc(scope, locus, depth + 1) > - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_GTE: result = (left()->calc(scope, locus, depth + 1) >= - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_ADD: result = (left()->calc(scope, locus, depth + 1) + - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_SUB: result = (left()->calc(scope, locus, depth + 1) - - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_MUL: result = (left()->calc(scope, locus, depth + 1) * - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_DIV: result = (left()->calc(scope, locus, depth + 1) / - right()->calc(scope, locus, depth + 1)); + right()->calc(scope, locus, depth + 1)); break; case O_NEG: @@ -345,16 +345,16 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) ptr_op_t next = right(); while (next) { - ptr_op_t value_op; - if (next->kind == O_CONS) { - value_op = next->left(); - next = next->right(); - } else { - value_op = next; - next = NULL; - } - temp.push_back(value_op->calc(scope, locus, depth + 1)); - DEBUG("op.cons", "temp now = " << temp); + ptr_op_t value_op; + if (next->kind == O_CONS) { + value_op = next->left(); + next = next->right(); + } else { + value_op = next; + next = NULL; + } + temp.push_back(value_op->calc(scope, locus, depth + 1)); + DEBUG("op.cons", "temp now = " << temp); } result = temp; } @@ -373,15 +373,15 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) if (has_right()) { ptr_op_t next = right(); while (next) { - ptr_op_t value_op; - if (next->kind == O_SEQ) { - value_op = next->left(); - next = next->right(); - } else { - value_op = next; - next = NULL; - } - result = value_op->calc(seq_scope, locus, depth + 1); + ptr_op_t value_op; + if (next->kind == O_SEQ) { + value_op = next->left(); + next = next->right(); + } else { + value_op = next; + next = NULL; + } + result = value_op->calc(seq_scope, locus, depth + 1); } } break; @@ -415,7 +415,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) namespace { bool print_cons(std::ostream& out, const expr_t::const_ptr_op_t op, - const expr_t::op_t::context_t& context) + const expr_t::op_t::context_t& context) { bool found = false; @@ -426,15 +426,15 @@ namespace { if (op->has_right()) { out << ", "; if (op->right()->kind == expr_t::op_t::O_CONS) - found = print_cons(out, op->right(), context); + found = print_cons(out, op->right(), context); else if (op->right()->print(out, context)) - found = true; + found = true; } return found; } bool print_seq(std::ostream& out, const expr_t::const_ptr_op_t op, - const expr_t::op_t::context_t& context) + const expr_t::op_t::context_t& context) { bool found = false; @@ -446,9 +446,9 @@ namespace { out << "; "; if (op->right()->kind == expr_t::op_t::O_CONS) - found = print_cons(out, op->right(), context); + found = print_cons(out, op->right(), context); else if (op->right()->print(out, context)) - found = true; + found = true; } return found; @@ -643,13 +643,13 @@ bool expr_t::op_t::print(std::ostream& out, const context_t& context) const found = true; if (has_right()) { if (right()->kind == O_SEQ) { - if (right()->print(out, context)) - found = true; + if (right()->print(out, context)) + found = true; } else { - out << "("; - if (has_right() && right()->print(out, context)) - found = true; - out << ")"; + out << "("; + if (has_right() && right()->print(out, context)) + found = true; + out << ")"; } } else { out << "()"; @@ -709,32 +709,32 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const case O_DEFINE: out << "O_DEFINE"; break; case O_LOOKUP: out << "O_LOOKUP"; break; - case O_CALL: out << "O_CALL"; break; + case O_CALL: out << "O_CALL"; break; case O_EXPAND: out << "O_EXPAND"; break; - case O_MATCH: out << "O_MATCH"; break; + case O_MATCH: out << "O_MATCH"; break; - case O_NOT: out << "O_NOT"; break; - case O_NEG: out << "O_NEG"; break; + case O_NOT: out << "O_NOT"; break; + case O_NEG: out << "O_NEG"; break; - case O_ADD: out << "O_ADD"; break; - case O_SUB: out << "O_SUB"; break; - case O_MUL: out << "O_MUL"; break; - case O_DIV: out << "O_DIV"; break; + case O_ADD: out << "O_ADD"; break; + case O_SUB: out << "O_SUB"; break; + case O_MUL: out << "O_MUL"; break; + case O_DIV: out << "O_DIV"; break; - case O_EQ: out << "O_EQ"; break; - case O_LT: out << "O_LT"; break; - case O_LTE: out << "O_LTE"; break; - case O_GT: out << "O_GT"; break; - case O_GTE: out << "O_GTE"; break; + case O_EQ: out << "O_EQ"; break; + case O_LT: out << "O_LT"; break; + case O_LTE: out << "O_LTE"; break; + case O_GT: out << "O_GT"; break; + case O_GTE: out << "O_GTE"; break; - case O_AND: out << "O_AND"; break; - case O_OR: out << "O_OR"; break; + case O_AND: out << "O_AND"; break; + case O_OR: out << "O_OR"; break; case O_QUERY: out << "O_QUERY"; break; - case O_COLON: out << "O_COLON"; break; + case O_COLON: out << "O_COLON"; break; - case O_CONS: out << "O_CONS"; break; - case O_SEQ: out << "O_SEQ"; break; + case O_CONS: out << "O_CONS"; break; + case O_SEQ: out << "O_SEQ"; break; case LAST: default: @@ -750,7 +750,7 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const if (left()) { left()->dump(out, depth + 1); if (kind > UNARY_OPERATORS && has_right()) - right()->dump(out, depth + 1); + right()->dump(out, depth + 1); } else if (kind > UNARY_OPERATORS) { assert(! has_right()); @@ -759,7 +759,7 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const } string op_context(const expr_t::ptr_op_t op, - const expr_t::ptr_op_t locus) + const expr_t::ptr_op_t locus) { ostream_pos_type start_pos, end_pos; expr_t::op_t::context_t context(op, locus, &start_pos, &end_pos); @@ -769,9 +769,9 @@ string op_context(const expr_t::ptr_op_t op, buf << "\n"; for (int i = 0; i <= end_pos; i++) { if (i > start_pos) - buf << "^"; + buf << "^"; else - buf << " "; + buf << " "; } } return buf.str(); @@ -56,13 +56,13 @@ public: private: mutable short refc; - ptr_op_t left_; + ptr_op_t left_; - variant<ptr_op_t, // used by all binary operators - value_t, // used by constant VALUE - string, // used by constant IDENT - expr_t::func_t // used by terminal FUNCTION - > data; + variant<ptr_op_t, // used by all binary operators + value_t, // used by constant VALUE + string, // used by constant IDENT + expr_t::func_t // used by terminal FUNCTION + > data; public: enum kind_t { @@ -225,13 +225,13 @@ public: private: void acquire() const { DEBUG("op.memory", - "Acquiring " << this << ", refc now " << refc + 1); + "Acquiring " << this << ", refc now " << refc + 1); assert(refc >= 0); refc++; } void release() const { DEBUG("op.memory", - "Releasing " << this << ", refc now " << refc - 1); + "Releasing " << this << ", refc now " << refc - 1); assert(refc > 0); if (--refc == 0) checked_delete(this); @@ -253,28 +253,28 @@ private: public: static ptr_op_t new_node(kind_t _kind, ptr_op_t _left = NULL, - ptr_op_t _right = NULL); + ptr_op_t _right = NULL); ptr_op_t compile(scope_t& scope, const int depth = 0); value_t calc(scope_t& scope, ptr_op_t * locus = NULL, - const int depth = 0); + const int depth = 0); struct context_t { - ptr_op_t expr_op; - ptr_op_t op_to_find; + ptr_op_t expr_op; + ptr_op_t op_to_find; ostream_pos_type * start_pos; ostream_pos_type * end_pos; - bool relaxed; + bool relaxed; context_t(const ptr_op_t& _expr_op = NULL, - const ptr_op_t& _op_to_find = NULL, - ostream_pos_type * const _start_pos = NULL, - ostream_pos_type * const _end_pos = NULL, - const bool _relaxed = true) + const ptr_op_t& _op_to_find = NULL, + ostream_pos_type * const _start_pos = NULL, + ostream_pos_type * const _end_pos = NULL, + const bool _relaxed = true) : expr_op(_expr_op), op_to_find(_op_to_find), - start_pos(_start_pos), end_pos(_end_pos), - relaxed(_relaxed) {} + start_pos(_start_pos), end_pos(_end_pos), + relaxed(_relaxed) {} }; bool print(std::ostream& out, const context_t& context = context_t()) const; @@ -300,8 +300,8 @@ private: ar & temp_op; } if (Archive::is_loading::value || kind == VALUE || kind == IDENT || - (kind > UNARY_OPERATORS && - (! has_right() || ! right()->is_function()))) { + (kind > UNARY_OPERATORS && + (! has_right() || ! right()->is_function()))) { ar & data; } else { variant<ptr_op_t, value_t, string, expr_t::func_t> temp_data; @@ -337,7 +337,7 @@ expr_t::op_t::wrap_functor(const expr_t::func_t& fobj) { #define WRAP_FUNCTOR(x) expr_t::op_t::wrap_functor(x) string op_context(const expr_t::ptr_op_t op, - const expr_t::ptr_op_t locus = NULL); + const expr_t::ptr_op_t locus = NULL); } // namespace ledger diff --git a/src/option.cc b/src/option.cc index b375dd8d..16f7713d 100644 --- a/src/option.cc +++ b/src/option.cc @@ -44,9 +44,9 @@ namespace { char * p = buf; foreach (char ch, name) { if (ch == '-') - *p++ = '_'; + *p++ = '_'; else - *p++ = ch; + *p++ = ch; } *p++ = '_'; *p = '\0'; @@ -75,30 +75,30 @@ namespace { } void process_option(const string& whence, const expr_t::func_t& opt, - scope_t& scope, const char * arg, const string& name) + scope_t& scope, const char * arg, const string& name) { try { call_scope_t args(scope); args.push_back(string_value(whence)); if (arg) - args.push_back(string_value(arg)); + args.push_back(string_value(arg)); opt(args); } catch (const std::exception& err) { if (name[0] == '-') - add_error_context(_("While parsing option '%1'") << name); - + add_error_context(_("While parsing option '%1'") << name); + else - add_error_context(_("While parsing environent variable '%1'") << name); + add_error_context(_("While parsing environent variable '%1'") << name); throw; } } } bool process_option(const string& whence, const string& name, scope_t& scope, - const char * arg, const string& varname) + const char * arg, const string& varname) { op_bool_tuple opt(find_option(scope, name)); if (opt.first) { @@ -109,9 +109,9 @@ bool process_option(const string& whence, const string& name, scope_t& scope, } void process_environment(const char ** envp, const string& tag, - scope_t& scope) + scope_t& scope) { - const char * tag_p = tag.c_str(); + const char * tag_p = tag.c_str(); string::size_type tag_len = tag.length(); assert(tag_p); @@ -123,25 +123,25 @@ void process_environment(const char ** envp, const string& tag, char * r = buf; const char * q; for (q = *p + tag_len; - *q && *q != '=' && r - buf < 8191; - q++) - if (*q == '_') - *r++ = '-'; - else - *r++ = static_cast<char>(std::tolower(*q)); + *q && *q != '=' && r - buf < 8191; + q++) + if (*q == '_') + *r++ = '-'; + else + *r++ = static_cast<char>(std::tolower(*q)); *r = '\0'; if (*q == '=') { - try { - string value = string(*p, q - *p); - if (! value.empty()) - process_option(string("$") + buf, string(buf), scope, q + 1, value); - } - catch (const std::exception& err) { - add_error_context(_("While parsing environment variable option '%1':") - << *p); - throw; - } + try { + string value = string(*p, q - *p); + if (! value.empty()) + process_option(string("$") + buf, string(buf), scope, q + 1, value); + } + catch (const std::exception& err) { + add_error_context(_("While parsing environment variable option '%1':") + << *p); + throw; + } } } } @@ -178,9 +178,9 @@ strings_list process_arguments(strings_list args, scope_t& scope) // --long-option or -s if ((*i)[1] == '-') { if ((*i)[2] == '\0') { - DEBUG("option.args", " it's a --, ending options processing"); - anywhere = false; - continue; + DEBUG("option.args", " it's a --, ending options processing"); + anywhere = false; + continue; } DEBUG("option.args", " it's an option string"); @@ -190,26 +190,26 @@ strings_list process_arguments(strings_list args, scope_t& scope) const char * value = NULL; if (const char * p = std::strchr(name, '=')) { - opt_name = string(name, p - name); - value = ++p; - DEBUG("option.args", " read option value from option: " << value); + opt_name = string(name, p - name); + value = ++p; + DEBUG("option.args", " read option value from option: " << value); } else { - opt_name = name; + opt_name = name; } op_bool_tuple opt(find_option(scope, opt_name)); if (! opt.first) - throw_(option_error, _("Illegal option --%1") << name); + throw_(option_error, _("Illegal option --%1") << name); if (opt.second && ! value && ++i != args.end() && value == NULL) { - value = (*i).c_str(); - DEBUG("option.args", " read option value from arg: " << value); - if (value == NULL) - throw_(option_error, _("Missing option argument for --%1") << name); + value = (*i).c_str(); + DEBUG("option.args", " read option value from arg: " << value); + if (value == NULL) + throw_(option_error, _("Missing option argument for --%1") << name); } process_option(string("--") + name, - opt.first->as_function(), scope, value, - string("--") + name); + opt.first->as_function(), scope, value, + string("--") + name); } else if ((*i)[1] == '\0') { throw_(option_error, _("illegal option -%1") << (*i)[0]); @@ -221,24 +221,24 @@ strings_list process_arguments(strings_list args, scope_t& scope) int x = 1; for (char c = (*i)[x]; c != '\0'; x++, c = (*i)[x]) { - op_bool_tuple opt(find_option(scope, c)); - if (! opt.first) - throw_(option_error, _("Illegal option -%1") << c); + op_bool_tuple opt(find_option(scope, c)); + if (! opt.first) + throw_(option_error, _("Illegal option -%1") << c); - option_queue.push_back(op_bool_char_tuple(opt.first, opt.second, c)); + option_queue.push_back(op_bool_char_tuple(opt.first, opt.second, c)); } foreach (op_bool_char_tuple& o, option_queue) { - const char * value = NULL; - if (o.truth && ++i != args.end()) { - value = (*i).c_str(); - DEBUG("option.args", " read option value from arg: " << value); - if (value == NULL) - throw_(option_error, - _("Missing option argument for -%1") << o.ch); - } - process_option(string("-") + o.ch, o.op->as_function(), scope, value, - string("-") + o.ch); + const char * value = NULL; + if (o.truth && ++i != args.end()) { + value = (*i).c_str(); + DEBUG("option.args", " read option value from arg: " << value); + if (value == NULL) + throw_(option_error, + _("Missing option argument for -%1") << o.ch); + } + process_option(string("-") + o.ch, o.op->as_function(), scope, value, + string("-") + o.ch); } } } diff --git a/src/option.h b/src/option.h index f11497a4..91ff26f9 100644 --- a/src/option.h +++ b/src/option.h @@ -52,10 +52,10 @@ template <typename T> class option_t { protected: - const char * name; + const char * name; string::size_type name_len; - const char ch; - bool handled; + const char ch; + bool handled; optional<string> source; option_t& operator=(const option_t&); @@ -63,7 +63,7 @@ protected: public: T * parent; value_t value; - bool wants_arg; + bool wants_arg; option_t(const char * _name, const char _ch = '\0') : name(_name), name_len(std::strlen(name)), ch(_ch), @@ -93,11 +93,11 @@ public: out.width(24); out << std::right << desc(); if (wants_arg) { - out << " = "; - value.print(out, 42); + out << " = "; + value.print(out, 42); } else { - out.width(45); - out << ' '; + out.width(45); + out << ' '; } out << std::left << *source << std::endl; } @@ -108,10 +108,10 @@ public: out << "--"; for (const char * p = name; *p; p++) { if (*p == '_') { - if (*(p + 1)) - out << '-'; + if (*(p + 1)) + out << '-'; } else { - out << *p; + out << *p; } } if (ch) @@ -145,7 +145,7 @@ public: on_with(whence, string_value(str)); } virtual void on_with(const optional<string>& whence, - const value_t& val) { + const value_t& val) { handled = true; value = val; source = whence; @@ -162,11 +162,11 @@ public: virtual void handler(call_scope_t& args) { if (wants_arg) { if (args.size() < 2) - throw_(std::runtime_error, _("No argument provided for %1") << desc()); + throw_(std::runtime_error, _("No argument provided for %1") << desc()); else if (args.size() > 2) - throw_(std::runtime_error, _("To many arguments provided for %1") << desc()); + throw_(std::runtime_error, _("To many arguments provided for %1") << desc()); else if (! args[0].is_string()) - throw_(std::runtime_error, _("Context argument for %1 not a string") << desc()); + throw_(std::runtime_error, _("Context argument for %1 not a string") << desc()); on_with(args[0].as_string(), args[1]); } else if (args.size() < 1) { @@ -194,9 +194,9 @@ public: } else if (wants_arg) { if (handled) - return value; + return value; else - return NULL_VALUE; + return NULL_VALUE; } else { return handled; @@ -204,13 +204,13 @@ public: } }; -#define BEGIN(type, name) \ +#define BEGIN(type, name) \ struct name ## option_t : public option_t<type> -#define CTOR(type, name) \ +#define CTOR(type, name) \ name ## option_t() : option_t<type>(#name) -#define DECL1(type, name, vartype, var, value) \ - vartype var ; \ +#define DECL1(type, name, vartype, var, value) \ + vartype var ; \ name ## option_t() : option_t<type>(#name), var(value) #define DO() virtual void handler_thunk(call_scope_t&) @@ -220,10 +220,10 @@ public: #define COPY_OPT(name, other) name ## handler(other.name ## handler) -#define MAKE_OPT_HANDLER(type, x) \ +#define MAKE_OPT_HANDLER(type, x) \ expr_t::op_t::wrap_functor(bind(&option_t<type>::handler_wrapper, x, _1)) -#define MAKE_OPT_FUNCTOR(type, x) \ +#define MAKE_OPT_FUNCTOR(type, x) \ expr_t::op_t::wrap_functor(bind(&option_t<type>::operator(), x, _1)) inline bool is_eq(const char * p, const char * n) { @@ -236,57 +236,57 @@ inline bool is_eq(const char * p, const char * n) { return *p == *n || (! *p && *n == '_' && ! *(n + 1)); } -#define OPT(name) \ - if (is_eq(p, #name)) \ +#define OPT(name) \ + if (is_eq(p, #name)) \ return ((name ## handler).parent = this, &(name ## handler)) -#define OPT_ALT(name, alt) \ - if (is_eq(p, #name) || is_eq(p, #alt)) \ +#define OPT_ALT(name, alt) \ + if (is_eq(p, #name) || is_eq(p, #alt)) \ return ((name ## handler).parent = this, &(name ## handler)) -#define OPT_(name) \ - if (! *(p + 1) || \ - ((name ## handler).wants_arg && \ - *(p + 1) == '_' && ! *(p + 2)) || \ - is_eq(p, #name)) \ +#define OPT_(name) \ + if (! *(p + 1) || \ + ((name ## handler).wants_arg && \ + *(p + 1) == '_' && ! *(p + 2)) || \ + is_eq(p, #name)) \ return ((name ## handler).parent = this, &(name ## handler)) -#define OPT_CH(name) \ - if (! *(p + 1) || \ - ((name ## handler).wants_arg && \ - *(p + 1) == '_' && ! *(p + 2))) \ +#define OPT_CH(name) \ + if (! *(p + 1) || \ + ((name ## handler).wants_arg && \ + *(p + 1) == '_' && ! *(p + 2))) \ return ((name ## handler).parent = this, &(name ## handler)) #define HANDLER(name) name ## handler #define HANDLED(name) HANDLER(name) -#define OPTION(type, name) \ - BEGIN(type, name) \ - { \ - CTOR(type, name) {} \ - } \ +#define OPTION(type, name) \ + BEGIN(type, name) \ + { \ + CTOR(type, name) {} \ + } \ END(name) -#define OPTION_(type, name, body) \ - BEGIN(type, name) \ - { \ - CTOR(type, name) {} \ - body \ - } \ +#define OPTION_(type, name, body) \ + BEGIN(type, name) \ + { \ + CTOR(type, name) {} \ + body \ + } \ END(name) -#define OPTION__(type, name, body) \ - BEGIN(type, name) \ - { \ - body \ - } \ +#define OPTION__(type, name, body) \ + BEGIN(type, name) \ + { \ + body \ + } \ END(name) bool process_option(const string& whence, const string& name, scope_t& scope, - const char * arg, const string& varname); + const char * arg, const string& varname); void process_environment(const char ** envp, const string& tag, - scope_t& scope); + scope_t& scope); strings_list process_arguments(strings_list args, scope_t& scope); diff --git a/src/output.cc b/src/output.cc index 5cef19bc..de0444cf 100644 --- a/src/output.cc +++ b/src/output.cc @@ -40,10 +40,10 @@ namespace ledger { -format_posts::format_posts(report_t& _report, - const string& format, - const optional<string>& _prepend_format, - std::size_t _prepend_width) +format_posts::format_posts(report_t& _report, + const string& format, + const optional<string>& _prepend_format, + std::size_t _prepend_width) : report(_report), prepend_width(_prepend_width), last_xact(NULL), last_post(NULL), first_report_title(true) { @@ -56,9 +56,9 @@ format_posts::format_posts(report_t& _report, const char * n = p + 2; if (const char * p = std::strstr(n, "%/")) { next_lines_format.parse_format(string(n, 0, p - n), - first_line_format); + first_line_format); between_format.parse_format(string(p + 2), - first_line_format); + first_line_format); } else { next_lines_format.parse_format(string(n), first_line_format); } @@ -86,16 +86,16 @@ void format_posts::operator()(post_t& post) if (! report_title.empty()) { if (first_report_title) - first_report_title = false; + first_report_title = false; else - out << '\n'; + out << '\n'; value_scope_t val_scope(string_value(report_title)); bind_scope_t inner_scope(bound_scope, val_scope); format_t group_title_format; group_title_format - .parse_format(report.HANDLER(group_title_format_).str()); + .parse_format(report.HANDLER(group_title_format_).str()); out << group_title_format(inner_scope); @@ -109,8 +109,8 @@ void format_posts::operator()(post_t& post) if (last_xact != post.xact) { if (last_xact) { - bind_scope_t xact_scope(report, *last_xact); - out << between_format(xact_scope); + bind_scope_t xact_scope(report, *last_xact); + out << between_format(xact_scope); } out << first_line_format(bound_scope); last_xact = post.xact; @@ -127,10 +127,10 @@ void format_posts::operator()(post_t& post) } } -format_accounts::format_accounts(report_t& _report, - const string& format, - const optional<string>& _prepend_format, - std::size_t _prepend_width) +format_accounts::format_accounts(report_t& _report, + const string& format, + const optional<string>& _prepend_format, + std::size_t _prepend_width) : report(_report), prepend_width(_prepend_width), disp_pred(), first_report_title(true) { @@ -172,16 +172,16 @@ std::size_t format_accounts::post_account(account_t& account, const bool flat) if (! report_title.empty()) { if (first_report_title) - first_report_title = false; + first_report_title = false; else - out << '\n'; + out << '\n'; value_scope_t val_scope(string_value(report_title)); bind_scope_t inner_scope(bound_scope, val_scope); format_t group_title_format; group_title_format - .parse_format(report.HANDLER(group_title_format_).str()); + .parse_format(report.HANDLER(group_title_format_).str()); out << group_title_format(inner_scope); @@ -203,7 +203,7 @@ std::size_t format_accounts::post_account(account_t& account, const bool flat) std::pair<std::size_t, std::size_t> format_accounts::mark_accounts(account_t& account, const bool flat) { - std::size_t visited = 0; + std::size_t visited = 0; std::size_t to_display = 0; foreach (accounts_map::value_type& pair, account.accounts) { @@ -218,7 +218,7 @@ format_accounts::mark_accounts(account_t& account, const bool flat) DEBUG("account.display", " it was visited itself"); DEBUG("account.display", " it has " << visited << " visited children"); DEBUG("account.display", - " it has " << to_display << " children to display"); + " it has " << to_display << " children to display"); #endif if (account.parent && @@ -226,10 +226,10 @@ format_accounts::mark_accounts(account_t& account, const bool flat) bind_scope_t bound_scope(report, account); call_scope_t call_scope(bound_scope); if ((! flat && to_display > 1) || - ((flat || to_display != 1 || - account.has_xflags(ACCOUNT_EXT_VISITED)) && - (report.HANDLED(empty) || report.fn_display_total(call_scope)) && - disp_pred(bound_scope))) { + ((flat || to_display != 1 || + account.has_xflags(ACCOUNT_EXT_VISITED)) && + (report.HANDLED(empty) || report.fn_display_total(call_scope)) && + disp_pred(bound_scope))) { account.xdata().add_flags(ACCOUNT_EXT_TO_DISPLAY); DEBUG("account.display", "Marking account as TO_DISPLAY"); to_display = 1; @@ -246,7 +246,7 @@ void format_accounts::flush() if (report.HANDLED(display_)) { DEBUG("account.display", - "Account display predicate: " << report.HANDLER(display_).str()); + "Account display predicate: " << report.HANDLER(display_).str()); disp_pred.parse(report.HANDLER(display_).str()); } @@ -265,7 +265,7 @@ void format_accounts::flush() if (prepend_format) { static_cast<std::ostream&>(report.output_stream).width(prepend_width); static_cast<std::ostream&>(report.output_stream) - << prepend_format(bound_scope); + << prepend_format(bound_scope); } out << total_line_format(bound_scope); @@ -346,12 +346,12 @@ void report_commodities::operator()(post_t& post) annotated_commodity_t& ann_comm(as_annotated_commodity(comm)); if (ann_comm.details.price) { std::map<commodity_t *, std::size_t>::iterator i = - commodities.find(&ann_comm.details.price->commodity()); + commodities.find(&ann_comm.details.price->commodity()); if (i == commodities.end()) - commodities.insert - (commodities_pair(&ann_comm.details.price->commodity(), 1)); + commodities.insert + (commodities_pair(&ann_comm.details.price->commodity(), 1)); else - (*i).second++; + (*i).second++; } } diff --git a/src/output.h b/src/output.h index a19c6235..ac3925c4 100644 --- a/src/output.h +++ b/src/output.h @@ -69,8 +69,8 @@ protected: public: format_posts(report_t& _report, const string& format, - const optional<string>& _prepend_format = none, - std::size_t _prepend_width = 0); + const optional<string>& _prepend_format = none, + std::size_t _prepend_width = 0); virtual ~format_posts() { TRACE_DTOR(format_posts); } @@ -83,8 +83,8 @@ public: virtual void operator()(post_t& post); virtual void clear() { - last_xact = NULL; - last_post = NULL; + last_xact = NULL; + last_post = NULL; report_title = ""; @@ -109,8 +109,8 @@ protected: public: format_accounts(report_t& _report, const string& _format, - const optional<string>& _prepend_format = none, - std::size_t _prepend_width = 0); + const optional<string>& _prepend_format = none, + std::size_t _prepend_width = 0); virtual ~format_accounts() { TRACE_DTOR(format_accounts); } @@ -123,7 +123,7 @@ public: } virtual std::size_t post_account(account_t& account, const bool flat); - virtual void flush(); + virtual void flush(); virtual void operator()(account_t& account); diff --git a/src/parser.cc b/src/parser.cc index f52949ce..db989f07 100644 --- a/src/parser.cc +++ b/src/parser.cc @@ -37,7 +37,7 @@ namespace ledger { expr_t::ptr_op_t expr_t::parser_t::parse_value_term(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node; @@ -60,16 +60,16 @@ expr_t::parser_t::parse_value_term(std::istream& in, if (tok.kind == token_t::LPAREN) { op_t::kind_t kind = op_t::O_CALL; if (ident == "any" || ident == "all") - kind = op_t::O_EXPAND; + kind = op_t::O_EXPAND; ptr_op_t call_node(new op_t(kind)); call_node->set_left(node); node = call_node; - push_token(tok); // let the parser see it again + push_token(tok); // let the parser see it again node->set_right(parse_value_expr(in, tflags.plus_flags(PARSE_SINGLE))); if (node->has_right() && node->right()->kind == op_t::O_CONS) - node->set_right(node->right()->left()); + node->set_right(node->right()->left()); } else { push_token(tok); } @@ -78,7 +78,7 @@ expr_t::parser_t::parse_value_term(std::istream& in, case token_t::LPAREN: node = parse_value_expr(in, tflags.plus_flags(PARSE_PARTIAL) - .minus_flags(PARSE_SINGLE)); + .minus_flags(PARSE_SINGLE)); tok = next_token(in, tflags, ')'); if (node->kind == op_t::O_CONS) { @@ -98,7 +98,7 @@ expr_t::parser_t::parse_value_term(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_dot_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_value_term(in, tflags)); @@ -106,16 +106,16 @@ expr_t::parser_t::parse_dot_expr(std::istream& in, while (true) { token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::DOT) { - ptr_op_t prev(node); - node = new op_t(op_t::O_LOOKUP); - node->set_left(prev); - node->set_right(parse_value_term(in, tflags)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + ptr_op_t prev(node); + node = new op_t(op_t::O_LOOKUP); + node->set_left(prev); + node->set_right(parse_value_term(in, tflags)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); } else { - push_token(tok); - break; + push_token(tok); + break; } } } @@ -125,7 +125,7 @@ expr_t::parser_t::parse_dot_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_unary_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node; @@ -136,7 +136,7 @@ expr_t::parser_t::parse_unary_expr(std::istream& in, ptr_op_t term(parse_dot_expr(in, tflags)); if (! term) throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + _("%1 operator not followed by argument") << tok.symbol); // A very quick optimization if (term->kind == op_t::VALUE) { @@ -153,7 +153,7 @@ expr_t::parser_t::parse_unary_expr(std::istream& in, ptr_op_t term(parse_dot_expr(in, tflags)); if (! term) throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + _("%1 operator not followed by argument") << tok.symbol); // A very quick optimization if (term->kind == op_t::VALUE) { @@ -177,7 +177,7 @@ expr_t::parser_t::parse_unary_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_mul_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_unary_expr(in, tflags)); @@ -186,18 +186,18 @@ expr_t::parser_t::parse_mul_expr(std::istream& in, token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::STAR || tok.kind == token_t::SLASH || - tok.kind == token_t::KW_DIV) { - ptr_op_t prev(node); - node = new op_t(tok.kind == token_t::STAR ? - op_t::O_MUL : op_t::O_DIV); - node->set_left(prev); - node->set_right(parse_unary_expr(in, tflags)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + tok.kind == token_t::KW_DIV) { + ptr_op_t prev(node); + node = new op_t(tok.kind == token_t::STAR ? + op_t::O_MUL : op_t::O_DIV); + node->set_left(prev); + node->set_right(parse_unary_expr(in, tflags)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); } else { - push_token(tok); - break; + push_token(tok); + break; } } } @@ -207,7 +207,7 @@ expr_t::parser_t::parse_mul_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_add_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_mul_expr(in, tflags)); @@ -216,18 +216,18 @@ expr_t::parser_t::parse_add_expr(std::istream& in, token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::PLUS || - tok.kind == token_t::MINUS) { - ptr_op_t prev(node); - node = new op_t(tok.kind == token_t::PLUS ? - op_t::O_ADD : op_t::O_SUB); - node->set_left(prev); - node->set_right(parse_mul_expr(in, tflags)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + tok.kind == token_t::MINUS) { + ptr_op_t prev(node); + node = new op_t(tok.kind == token_t::PLUS ? + op_t::O_ADD : op_t::O_SUB); + node->set_left(prev); + node->set_right(parse_mul_expr(in, tflags)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); } else { - push_token(tok); - break; + push_token(tok); + break; } } } @@ -237,70 +237,70 @@ expr_t::parser_t::parse_add_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_logic_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_add_expr(in, tflags)); if (node && ! tflags.has_flags(PARSE_SINGLE)) { while (true) { - op_t::kind_t kind = op_t::LAST; + op_t::kind_t kind = op_t::LAST; parse_flags_t _flags = tflags; - token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); - bool negate = false; + token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); + bool negate = false; switch (tok.kind) { case token_t::DEFINE: - kind = op_t::O_DEFINE; - break; + kind = op_t::O_DEFINE; + break; case token_t::EQUAL: - if (tflags.has_flags(PARSE_NO_ASSIGN)) - tok.rewind(in); - else - kind = op_t::O_EQ; - break; + if (tflags.has_flags(PARSE_NO_ASSIGN)) + tok.rewind(in); + else + kind = op_t::O_EQ; + break; case token_t::NEQUAL: - kind = op_t::O_EQ; - negate = true; - break; + kind = op_t::O_EQ; + negate = true; + break; case token_t::MATCH: - kind = op_t::O_MATCH; - break; + kind = op_t::O_MATCH; + break; case token_t::NMATCH: - kind = op_t::O_MATCH; - negate = true; - break; + kind = op_t::O_MATCH; + negate = true; + break; case token_t::LESS: - kind = op_t::O_LT; - break; + kind = op_t::O_LT; + break; case token_t::LESSEQ: - kind = op_t::O_LTE; - break; + kind = op_t::O_LTE; + break; case token_t::GREATER: - kind = op_t::O_GT; - break; + kind = op_t::O_GT; + break; case token_t::GREATEREQ: - kind = op_t::O_GTE; - break; + kind = op_t::O_GTE; + break; default: - push_token(tok); - goto exit_loop; + push_token(tok); + goto exit_loop; } if (kind != op_t::LAST) { - ptr_op_t prev(node); - node = new op_t(kind); - node->set_left(prev); - node->set_right(parse_add_expr(in, _flags)); - - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); - - if (negate) { - prev = node; - node = new op_t(op_t::O_NOT); - node->set_left(prev); - } + ptr_op_t prev(node); + node = new op_t(kind); + node->set_left(prev); + node->set_right(parse_add_expr(in, _flags)); + + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); + + if (negate) { + prev = node; + node = new op_t(op_t::O_NOT); + node->set_left(prev); + } } } } @@ -311,7 +311,7 @@ expr_t::parser_t::parse_logic_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_and_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_logic_expr(in, tflags)); @@ -320,16 +320,16 @@ expr_t::parser_t::parse_and_expr(std::istream& in, token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::KW_AND) { - ptr_op_t prev(node); - node = new op_t(op_t::O_AND); - node->set_left(prev); - node->set_right(parse_logic_expr(in, tflags)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + ptr_op_t prev(node); + node = new op_t(op_t::O_AND); + node->set_left(prev); + node->set_right(parse_logic_expr(in, tflags)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); } else { - push_token(tok); - break; + push_token(tok); + break; } } } @@ -338,7 +338,7 @@ expr_t::parser_t::parse_and_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_or_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_and_expr(in, tflags)); @@ -347,16 +347,16 @@ expr_t::parser_t::parse_or_expr(std::istream& in, token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::KW_OR) { - ptr_op_t prev(node); - node = new op_t(op_t::O_OR); - node->set_left(prev); - node->set_right(parse_and_expr(in, tflags)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + ptr_op_t prev(node); + node = new op_t(op_t::O_OR); + node->set_left(prev); + node->set_right(parse_and_expr(in, tflags)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); } else { - push_token(tok); - break; + push_token(tok); + break; } } } @@ -365,7 +365,7 @@ expr_t::parser_t::parse_or_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_querycolon_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_or_expr(in, tflags)); @@ -378,8 +378,8 @@ expr_t::parser_t::parse_querycolon_expr(std::istream& in, node->set_left(prev); node->set_right(parse_or_expr(in, tflags)); if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT), ':'); prev = node->right(); @@ -387,42 +387,42 @@ expr_t::parser_t::parse_querycolon_expr(std::istream& in, subnode->set_left(prev); subnode->set_right(parse_or_expr(in, tflags)); if (! subnode->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); node->set_right(subnode); } else if (tok.kind == token_t::KW_IF) { ptr_op_t if_op(parse_or_expr(in, tflags)); if (! if_op) - throw_(parse_error, _("'if' keyword not followed by argument")); + throw_(parse_error, _("'if' keyword not followed by argument")); tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); if (tok.kind == token_t::KW_ELSE) { - ptr_op_t else_op(parse_or_expr(in, tflags)); - if (! else_op) - throw_(parse_error, _("'else' keyword not followed by argument")); + ptr_op_t else_op(parse_or_expr(in, tflags)); + if (! else_op) + throw_(parse_error, _("'else' keyword not followed by argument")); - ptr_op_t subnode = new op_t(op_t::O_COLON); - subnode->set_left(node); - subnode->set_right(else_op); + ptr_op_t subnode = new op_t(op_t::O_COLON); + subnode->set_left(node); + subnode->set_right(else_op); - node = new op_t(op_t::O_QUERY); - node->set_left(if_op); - node->set_right(subnode); + node = new op_t(op_t::O_QUERY); + node->set_left(if_op); + node->set_right(subnode); } else { - ptr_op_t null_node = new op_t(op_t::VALUE); - null_node->set_value(NULL_VALUE); + ptr_op_t null_node = new op_t(op_t::VALUE); + null_node->set_value(NULL_VALUE); - ptr_op_t subnode = new op_t(op_t::O_COLON); - subnode->set_left(node); - subnode->set_right(null_node); + ptr_op_t subnode = new op_t(op_t::O_COLON); + subnode->set_left(node); + subnode->set_right(null_node); - node = new op_t(op_t::O_QUERY); - node->set_left(if_op); - node->set_right(subnode); + node = new op_t(op_t::O_QUERY); + node->set_left(if_op); + node->set_right(subnode); - push_token(tok); + push_token(tok); } } else { @@ -434,7 +434,7 @@ expr_t::parser_t::parse_querycolon_expr(std::istream& in, expr_t::ptr_op_t expr_t::parser_t::parse_value_expr(std::istream& in, - const parse_flags_t& tflags) const + const parse_flags_t& tflags) const { ptr_op_t node(parse_querycolon_expr(in, tflags)); @@ -449,21 +449,21 @@ expr_t::parser_t::parse_value_expr(std::istream& in, node->set_left(prev); node->set_right(parse_value_expr(in, tflags)); if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol); + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol); tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); } if (tok.kind != token_t::TOK_EOF) { if (tflags.has_flags(PARSE_PARTIAL)) - push_token(tok); + push_token(tok); else - tok.unexpected(); + tok.unexpected(); } } else if (! tflags.has_flags(PARSE_PARTIAL) && - ! tflags.has_flags(PARSE_SINGLE)) { + ! tflags.has_flags(PARSE_SINGLE)) { throw_(parse_error, _("Failed to parse value expression")); } @@ -471,9 +471,9 @@ expr_t::parser_t::parse_value_expr(std::istream& in, } expr_t::ptr_op_t -expr_t::parser_t::parse(std::istream& in, - const parse_flags_t& flags, - const optional<string>& original_string) +expr_t::parser_t::parse(std::istream& in, + const parse_flags_t& flags, + const optional<string>& original_string) { try { ptr_op_t top_node = parse_value_expr(in, flags); @@ -492,11 +492,11 @@ expr_t::parser_t::parse(std::istream& in, std::streamoff end_pos = 0; if (in.good()) - end_pos = in.tellg(); + end_pos = in.tellg(); std::streamoff pos = end_pos; if (pos > 0) - pos -= lookahead.length; + pos -= lookahead.length; DEBUG("parser.error", "original_string = '" << *original_string << "'"); DEBUG("parser.error", " pos = " << pos); @@ -505,8 +505,8 @@ expr_t::parser_t::parse(std::istream& in, DEBUG("parser.error", " token length = " << lookahead.length); add_error_context(line_context(*original_string, - static_cast<string::size_type>(pos), - static_cast<string::size_type>(end_pos))); + static_cast<string::size_type>(pos), + static_cast<string::size_type>(end_pos))); } throw; } diff --git a/src/parser.h b/src/parser.h index 2693fc79..93ea994f 100644 --- a/src/parser.h +++ b/src/parser.h @@ -50,10 +50,10 @@ namespace ledger { class expr_t::parser_t : public noncopyable { mutable token_t lookahead; - mutable bool use_lookahead; + mutable bool use_lookahead; token_t& next_token(std::istream& in, const parse_flags_t& tflags, - const char expecting = '\0') const { + const char expecting = '\0') const { if (use_lookahead) use_lookahead = false; else @@ -76,25 +76,25 @@ class expr_t::parser_t : public noncopyable } ptr_op_t parse_value_term(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_dot_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_unary_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_mul_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_add_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_logic_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_and_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_or_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_querycolon_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; ptr_op_t parse_value_expr(std::istream& in, - const parse_flags_t& flags) const; + const parse_flags_t& flags) const; public: parser_t() : use_lookahead(false) { @@ -104,9 +104,9 @@ public: TRACE_DTOR(parser_t); } - ptr_op_t parse(std::istream& in, - const parse_flags_t& flags = PARSE_DEFAULT, - const optional<string>& original_string = NULL); + ptr_op_t parse(std::istream& in, + const parse_flags_t& flags = PARSE_DEFAULT, + const optional<string>& original_string = NULL); }; } // namespace ledger diff --git a/src/pool.cc b/src/pool.cc index 5285be92..618a43c5 100644 --- a/src/pool.cc +++ b/src/pool.cc @@ -67,11 +67,11 @@ commodity_t * commodity_pool_t::create(const string& symbol) } DEBUG("pool.commodities", - "Creating commodity '" << commodity->symbol() << "'"); + "Creating commodity '" << commodity->symbol() << "'"); std::pair<commodities_map::iterator, bool> result = commodities.insert(commodities_map::value_type(commodity->mapping_key(), - commodity.get())); + commodity.get())); assert(result.second); return commodity.release(); @@ -111,7 +111,7 @@ commodity_pool_t::create(const string& symbol, const annotation_t& details) } string commodity_pool_t::make_qualified_name(const commodity_t& comm, - const annotation_t& details) + const annotation_t& details) { assert(details); @@ -125,7 +125,7 @@ string commodity_pool_t::make_qualified_name(const commodity_t& comm, #if defined(DEBUG_ON) if (comm.qualified_symbol) DEBUG("pool.commodities", "make_qualified_name for " - << *comm.qualified_symbol << std::endl << details); + << *comm.qualified_symbol << std::endl << details); #endif DEBUG("pool.commodities", "qualified_name is " << name.str()); @@ -154,7 +154,7 @@ commodity_pool_t::find(const string& symbol, const annotation_t& details) commodity_t * commodity_pool_t::find_or_create(const string& symbol, - const annotation_t& details) + const annotation_t& details) { commodity_t * comm = find_or_create(symbol); if (! comm) @@ -167,9 +167,9 @@ commodity_pool_t::find_or_create(const string& symbol, } commodity_t * -commodity_pool_t::create(commodity_t& comm, - const annotation_t& details, - const string& mapping_key) +commodity_pool_t::create(commodity_t& comm, + const annotation_t& details, + const string& mapping_key) { assert(comm); assert(details); @@ -182,8 +182,8 @@ commodity_pool_t::create(commodity_t& comm, assert(! commodity->qualified_symbol->empty()); DEBUG("pool.commodities", "Creating annotated commodity " - << "symbol " << commodity->symbol() - << " key " << mapping_key << std::endl << details); + << "symbol " << commodity->symbol() + << " key " << mapping_key << std::endl << details); // Add the fully annotated name to the map, so that this symbol may // quickly be found again. @@ -191,14 +191,14 @@ commodity_pool_t::create(commodity_t& comm, std::pair<commodities_map::iterator, bool> result = commodities.insert(commodities_map::value_type(mapping_key, - commodity.get())); + commodity.get())); assert(result.second); return commodity.release(); } -commodity_t * commodity_pool_t::find_or_create(commodity_t& comm, - const annotation_t& details) +commodity_t * commodity_pool_t::find_or_create(commodity_t& comm, + const annotation_t& details) { assert(comm); assert(details); @@ -213,12 +213,12 @@ commodity_t * commodity_pool_t::find_or_create(commodity_t& comm, return create(comm, details, name); } -void commodity_pool_t::exchange(commodity_t& commodity, - const amount_t& per_unit_cost, - const datetime_t& moment) +void commodity_pool_t::exchange(commodity_t& commodity, + const amount_t& per_unit_cost, + const datetime_t& moment) { DEBUG("commodity.prices.add", "exchanging commodity " << commodity - << " at per unit cost " << per_unit_cost << " on " << moment); + << " at per unit cost " << per_unit_cost << " on " << moment); commodity_t& base_commodity (commodity.annotated ? @@ -228,11 +228,11 @@ void commodity_pool_t::exchange(commodity_t& commodity, } cost_breakdown_t -commodity_pool_t::exchange(const amount_t& amount, - const amount_t& cost, - const bool is_per_unit, - const optional<datetime_t>& moment, - const optional<string>& tag) +commodity_pool_t::exchange(const amount_t& amount, + const amount_t& cost, + const bool is_per_unit, + const optional<datetime_t>& moment, + const optional<string>& tag) { DEBUG("commodity.prices.add", "exchange: " << amount << " for " << cost); DEBUG("commodity.prices.add", "exchange: is-per-unit = " << is_per_unit); @@ -261,7 +261,7 @@ commodity_pool_t::exchange(const amount_t& amount, breakdown.final_cost = ! is_per_unit ? cost : cost * amount.abs(); DEBUG("commodity.prices.add", - "exchange: final-cost = " << breakdown.final_cost); + "exchange: final-cost = " << breakdown.final_cost); if (current_annotation && current_annotation->price) breakdown.basis_cost @@ -270,10 +270,10 @@ commodity_pool_t::exchange(const amount_t& amount, breakdown.basis_cost = breakdown.final_cost; DEBUG("commodity.prices.add", - "exchange: basis-cost = " << breakdown.basis_cost); + "exchange: basis-cost = " << breakdown.basis_cost); annotation_t annotation(per_unit_cost, moment ? - moment->date() : optional<date_t>(), tag); + moment->date() : optional<date_t>(), tag); annotation.add_flags(ANNOTATION_PRICE_CALCULATED); if (moment) @@ -284,7 +284,7 @@ commodity_pool_t::exchange(const amount_t& amount, breakdown.amount = amount_t(amount, annotation); DEBUG("commodity.prices.add", - "exchange: amount = " << breakdown.amount); + "exchange: amount = " << breakdown.amount); return breakdown; } @@ -328,7 +328,7 @@ commodity_pool_t::parse_price_directive(char * line, bool do_not_add_price) DEBUG("commodity.download", "Looking up symbol: " << symbol); if (commodity_t * commodity = find_or_create(symbol)) { DEBUG("commodity.download", "Adding price for " << symbol << ": " - << point.when << " " << point.price); + << point.when << " " << point.price); if (! do_not_add_price) commodity->add_price(point.when, point.price, true); commodity->add_flags(COMMODITY_KNOWN); @@ -340,8 +340,8 @@ commodity_pool_t::parse_price_directive(char * line, bool do_not_add_price) commodity_t * commodity_pool_t::parse_price_expression(const std::string& str, - const bool add_prices, - const optional<datetime_t>& moment) + const bool add_prices, + const optional<datetime_t>& moment) { scoped_array<char> buf(new char[str.length() + 1]); @@ -354,9 +354,9 @@ commodity_pool_t::parse_price_expression(const std::string& str, if (commodity_t * commodity = find_or_create(trim_ws(buf.get()))) { if (price && add_prices) { for (char * p = std::strtok(price, ";"); - p; - p = std::strtok(NULL, ";")) { - commodity->add_price(moment ? *moment : CURRENT_TIME(), amount_t(p)); + p; + p = std::strtok(NULL, ";")) { + commodity->add_price(moment ? *moment : CURRENT_TIME(), amount_t(p)); } } return commodity; @@ -364,9 +364,9 @@ commodity_pool_t::parse_price_expression(const std::string& str, return NULL; } -void commodity_pool_t::print_pricemap(std::ostream& out, - const keep_details_t& keep, - const optional<datetime_t>& moment) +void commodity_pool_t::print_pricemap(std::ostream& out, + const keep_details_t& keep, + const optional<datetime_t>& moment) { typedef std::map<commodity_t *, commodity_t *> comm_map_t; @@ -391,44 +391,44 @@ void commodity_pool_t::print_pricemap(std::ostream& out, out << "\"" << comm->symbol() << "\";\n"; if (! comm->has_flags(COMMODITY_NOMARKET) && - (! commodity_pool_t::current_pool->default_commodity || - comm != commodity_pool_t::current_pool->default_commodity)) { + (! commodity_pool_t::current_pool->default_commodity || + comm != commodity_pool_t::current_pool->default_commodity)) { if (optional<commodity_t::varied_history_t&> vhist = - comm->varied_history()) { - foreach (const commodity_t::history_by_commodity_map::value_type& pair, - vhist->histories) { - datetime_t most_recent; - amount_t most_recent_amt; - foreach (const commodity_t::history_map::value_type& inner_pair, - pair.second.prices) { - if ((most_recent.is_not_a_date_time() || - inner_pair.first > most_recent) && - (! moment || inner_pair.first <= moment)) { - most_recent = inner_pair.first; - most_recent_amt = inner_pair.second; - } - } - - if (! most_recent.is_not_a_date_time()) { - out << " "; - if (commodity_t::symbol_needs_quotes(comm->symbol())) - out << comm->symbol(); - else - out << "\"" << comm->symbol() << "\""; - - out << " -> "; - - if (commodity_t::symbol_needs_quotes(pair.first->symbol())) - out << pair.first->symbol(); - else - out << "\"" << pair.first->symbol() << "\""; - - out << " [label=\"" - << most_recent_amt.number() << "\\n" - << format_date(most_recent.date(), FMT_WRITTEN) - << "\" fontcolor=\"#008e28\"];\n"; - } - } + comm->varied_history()) { + foreach (const commodity_t::history_by_commodity_map::value_type& pair, + vhist->histories) { + datetime_t most_recent; + amount_t most_recent_amt; + foreach (const commodity_t::history_map::value_type& inner_pair, + pair.second.prices) { + if ((most_recent.is_not_a_date_time() || + inner_pair.first > most_recent) && + (! moment || inner_pair.first <= moment)) { + most_recent = inner_pair.first; + most_recent_amt = inner_pair.second; + } + } + + if (! most_recent.is_not_a_date_time()) { + out << " "; + if (commodity_t::symbol_needs_quotes(comm->symbol())) + out << comm->symbol(); + else + out << "\"" << comm->symbol() << "\""; + + out << " -> "; + + if (commodity_t::symbol_needs_quotes(pair.first->symbol())) + out << pair.first->symbol(); + else + out << "\"" << pair.first->symbol() << "\""; + + out << " [label=\"" + << most_recent_amt.number() << "\\n" + << format_date(most_recent.date(), FMT_WRITTEN) + << "\" fontcolor=\"#008e28\"];\n"; + } + } } } } @@ -67,19 +67,19 @@ public: typedef std::map<string, commodity_t *> commodities_map; commodities_map commodities; - commodity_t * null_commodity; - commodity_t * default_commodity; + commodity_t * null_commodity; + commodity_t * default_commodity; - bool keep_base; // --base + bool keep_base; // --base optional<path> price_db; // --price-db= - long quote_leeway; // --leeway= - bool get_quotes; // --download + long quote_leeway; // --leeway= + bool get_quotes; // --download static shared_ptr<commodity_pool_t> current_pool; function<optional<price_point_t> - (commodity_t& commodity, const optional<commodity_t&>& in_terms_of)> + (commodity_t& commodity, const optional<commodity_t&>& in_terms_of)> get_commodity_quote; explicit commodity_pool_t(); @@ -91,7 +91,7 @@ public: } string make_qualified_name(const commodity_t& comm, - const annotation_t& details); + const annotation_t& details); commodity_t * create(const string& symbol); commodity_t * find(const string& name); @@ -100,26 +100,26 @@ public: commodity_t * create(const string& symbol, const annotation_t& details); commodity_t * find(const string& symbol, const annotation_t& details); commodity_t * find_or_create(const string& symbol, - const annotation_t& details); + const annotation_t& details); - commodity_t * create(commodity_t& comm, - const annotation_t& details, - const string& mapping_key); + commodity_t * create(commodity_t& comm, + const annotation_t& details, + const string& mapping_key); - commodity_t * find_or_create(commodity_t& comm, - const annotation_t& details); + commodity_t * find_or_create(commodity_t& comm, + const annotation_t& details); // Exchange one commodity for another, while recording the factored price. - void exchange(commodity_t& commodity, - const amount_t& per_unit_cost, - const datetime_t& moment); + void exchange(commodity_t& commodity, + const amount_t& per_unit_cost, + const datetime_t& moment); - cost_breakdown_t exchange(const amount_t& amount, - const amount_t& cost, - const bool is_per_unit = false, - const optional<datetime_t>& moment = none, - const optional<string>& tag = none); + cost_breakdown_t exchange(const amount_t& amount, + const amount_t& cost, + const bool is_per_unit = false, + const optional<datetime_t>& moment = none, + const optional<string>& tag = none); // Parse commodity prices from a textual representation @@ -128,14 +128,14 @@ public: commodity_t * parse_price_expression(const std::string& str, - const bool add_prices = true, - const optional<datetime_t>& moment = none); + const bool add_prices = true, + const optional<datetime_t>& moment = none); // Output the commodity price map for a given date as a DOT file - void print_pricemap(std::ostream& out, - const keep_details_t& keep, - const optional<datetime_t>& moment = none); + void print_pricemap(std::ostream& out, + const keep_details_t& keep, + const optional<datetime_t>& moment = none); #if defined(HAVE_BOOST_SERIALIZATION) private: diff --git a/src/post.cc b/src/post.cc index e182a731..3ef76f7f 100644 --- a/src/post.cc +++ b/src/post.cc @@ -50,7 +50,7 @@ bool post_t::has_tag(const string& tag) const } bool post_t::has_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask) const + const optional<mask_t>& value_mask) const { if (item_t::has_tag(tag_mask, value_mask)) return true; @@ -69,7 +69,7 @@ optional<string> post_t::get_tag(const string& tag) const } optional<string> post_t::get_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask) const + const optional<mask_t>& value_mask) const { if (optional<string> value = item_t::get_tag(tag_mask, value_mask)) return value; @@ -199,18 +199,18 @@ namespace { value_t get_commodity(post_t& post) { if (post.has_xdata() && - post.xdata().has_flags(POST_EXT_COMPOUND)) + post.xdata().has_flags(POST_EXT_COMPOUND)) return string_value(post.xdata().compound_value.to_amount() - .commodity().symbol()); + .commodity().symbol()); else return string_value(post.amount.commodity().symbol()); } value_t get_commodity_is_primary(post_t& post) { if (post.has_xdata() && - post.xdata().has_flags(POST_EXT_COMPOUND)) + post.xdata().has_flags(POST_EXT_COMPOUND)) return post.xdata().compound_value.to_amount() - .commodity().has_flags(COMMODITY_PRIMARY); + .commodity().has_flags(COMMODITY_PRIMARY); else return post.amount.commodity().has_flags(COMMODITY_PRIMARY); } @@ -223,7 +223,7 @@ namespace { if (post.cost) return *post.cost; else if (post.has_xdata() && - post.xdata().has_flags(POST_EXT_COMPOUND)) + post.xdata().has_flags(POST_EXT_COMPOUND)) return post.xdata().compound_value; else if (post.amount.is_null()) return 0L; @@ -255,37 +255,37 @@ namespace { if (env.has(0)) { if (env.value_at(0).is_long()) { - if (env.get<long>(0) > 2) - name = format_t::truncate(env->reported_account()->fullname(), - env.get<long>(0) - 2, - 2 /* account_abbrev_length */); - else - name = env->reported_account()->fullname(); + if (env.get<long>(0) > 2) + name = format_t::truncate(env->reported_account()->fullname(), + env.get<long>(0) - 2, + 2 /* account_abbrev_length */); + else + name = env->reported_account()->fullname(); } else { - account_t * account = NULL; - account_t * master = env->account; - while (master->parent) - master = master->parent; - - if (env.value_at(0).is_string()) { - name = env.get<string>(0); - account = master->find_account(name, false); - } - else if (env.value_at(0).is_mask()) { - name = env.get<mask_t>(0).str(); - account = master->find_account_re(name); - } - else { - throw_(std::runtime_error, - _("Expected string or mask for argument 1, but received %1") - << env.value_at(0).label()); - } - - if (! account) - throw_(std::runtime_error, - _("Could not find an account matching ") << env.value_at(0)); - else - return value_t(static_cast<scope_t *>(account)); + account_t * account = NULL; + account_t * master = env->account; + while (master->parent) + master = master->parent; + + if (env.value_at(0).is_string()) { + name = env.get<string>(0); + account = master->find_account(name, false); + } + else if (env.value_at(0).is_mask()) { + name = env.get<mask_t>(0).str(); + account = master->find_account_re(name); + } + else { + throw_(std::runtime_error, + _("Expected string or mask for argument 1, but received %1") + << env.value_at(0).label()); + } + + if (! account) + throw_(std::runtime_error, + _("Could not find an account matching ") << env.value_at(0)); + else + return value_t(static_cast<scope_t *>(account)); } } else { name = env->reported_account()->fullname(); @@ -300,10 +300,10 @@ namespace { value_t acct = account_name(scope); if (acct.is_string()) { if (env->has_flags(POST_VIRTUAL)) { - if (env->must_balance()) - acct = string_value(string("[") + acct.as_string() + "]"); - else - acct = string_value(string("(") + acct.as_string() + ")"); + if (env->must_balance()) + acct = string_value(string("[") + acct.as_string() + "]"); + else + acct = string_value(string("(") + acct.as_string() + ")"); } } return acct; @@ -330,7 +330,7 @@ namespace { if (post.has_xdata()) { post_t::xdata_t& xdata(post.xdata()); if (! xdata.value_date.is_not_a_date()) - return xdata.value_date; + return xdata.value_date; } return post.date(); } @@ -353,13 +353,13 @@ namespace { foreach (post_t * p, post.xact->posts) { bind_scope_t bound_scope(scope, *p); if (p == &post && args.has(1) && - ! args.get<expr_t&>(1).calc(bound_scope).to_boolean()) { - // If the user specifies any(EXPR, false), and the context is a - // posting, then that posting isn't considered by the test. - ; // skip it + ! args.get<expr_t&>(1).calc(bound_scope).to_boolean()) { + // If the user specifies any(EXPR, false), and the context is a + // posting, then that posting isn't considered by the test. + ; // skip it } else if (expr.calc(bound_scope).to_boolean()) { - return true; + return true; } } return false; @@ -375,13 +375,13 @@ namespace { foreach (post_t * p, post.xact->posts) { bind_scope_t bound_scope(scope, *p); if (p == &post && args.has(1) && - ! args.get<expr_t&>(1).calc(bound_scope).to_boolean()) { - // If the user specifies any(EXPR, false), and the context is a - // posting, then that posting isn't considered by the test. - ; // skip it + ! args.get<expr_t&>(1).calc(bound_scope).to_boolean()) { + // If the user specifies any(EXPR, false), and the context is a + // posting, then that posting isn't considered by the test. + ; // skip it } else if (! expr.calc(bound_scope).to_boolean()) { - return false; + return false; } } return true; @@ -389,7 +389,7 @@ namespace { } expr_t::ptr_op_t post_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (kind != symbol_t::FUNCTION) return item_t::lookup(kind, name); @@ -533,7 +533,7 @@ amount_t post_t::resolve_expr(scope_t& scope, expr_t& expr) } else { if (! result.is_amount()) throw_(amount_error, - _("Amount expressions must result in a simple amount")); + _("Amount expressions must result in a simple amount")); return result.as_amount(); } } @@ -571,7 +571,7 @@ bool post_t::valid() const posts_list::const_iterator i = std::find(xact->posts.begin(), - xact->posts.end(), this); + xact->posts.end(), this); if (i == xact->posts.end()) { DEBUG("ledger.validate", "post_t: ! found"); return false; @@ -608,7 +608,7 @@ void post_t::add_to_value(value_t& value, const optional<expr_t&>& expr) const } else if (expr) { bind_scope_t bound_scope(*expr->get_context(), - const_cast<post_t&>(*this)); + const_cast<post_t&>(*this)); #if 1 value_t temp(expr->calc(bound_scope)); add_or_set_value(value, temp); @@ -621,7 +621,7 @@ void post_t::add_to_value(value_t& value, const optional<expr_t&>& expr) const #endif } else if (xdata_ && xdata_->has_flags(POST_EXT_VISITED) && - ! xdata_->visited_value.is_null()) { + ! xdata_->visited_value.is_null()) { add_or_set_value(value, xdata_->visited_value); } else { @@ -708,18 +708,18 @@ void to_xml(std::ostream& out, const post_t& post) push_xml y(out, "metadata"); foreach (const item_t::string_map::value_type& pair, *post.metadata) { if (pair.second.first) { - push_xml z(out, "variable"); - { - push_xml z(out, "key"); - out << y.guard(pair.first); - } - { - push_xml z(out, "value"); - out << y.guard(*pair.second.first); - } + push_xml z(out, "variable"); + { + push_xml z(out, "key"); + out << y.guard(pair.first); + } + { + push_xml z(out, "value"); + out << y.guard(*pair.second.first); + } } else { - push_xml z(out, "tag"); - out << y.guard(pair.first); + push_xml z(out, "tag"); + out << y.guard(pair.first); } } } @@ -52,33 +52,33 @@ class account_t; class post_t : public item_t { public: -#define POST_VIRTUAL 0x0010 // the account was specified with (parens) +#define POST_VIRTUAL 0x0010 // the account was specified with (parens) #define POST_MUST_BALANCE 0x0020 // posting must balance in the transaction -#define POST_CALCULATED 0x0040 // posting's amount was calculated +#define POST_CALCULATED 0x0040 // posting's amount was calculated #define POST_COST_CALCULATED 0x0080 // posting's cost was calculated #define POST_COST_IN_FULL 0x0100 // cost specified using @@ #define POST_COST_FIXATED 0x0200 // cost is fixed using = indicator #define POST_ANONYMIZED 0x0400 // a temporary, anonymous posting - xact_t * xact; // only set for posts of regular xacts - account_t * account; + xact_t * xact; // only set for posts of regular xacts + account_t * account; - amount_t amount; // can be null until finalization + amount_t amount; // can be null until finalization optional<expr_t> amount_expr; optional<amount_t> cost; optional<amount_t> assigned_amount; post_t(account_t * _account = NULL, - flags_t _flags = ITEM_NORMAL) + flags_t _flags = ITEM_NORMAL) : item_t(_flags), xact(NULL), account(_account) { TRACE_CTOR(post_t, "account_t *, flags_t"); } - post_t(account_t * _account, - const amount_t& _amount, - flags_t _flags = ITEM_NORMAL, - const optional<string>& _note = none) + post_t(account_t * _account, + const amount_t& _amount, + flags_t _flags = ITEM_NORMAL, + const optional<string>& _note = none) : item_t(_flags, _note), xact(NULL), account(_account), amount(_amount) { @@ -101,11 +101,11 @@ public: virtual bool has_tag(const string& tag) const; virtual bool has_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask = none) const; + const optional<mask_t>& value_mask = none) const; virtual optional<string> get_tag(const string& tag) const; virtual optional<string> get_tag(const mask_t& tag_mask, - const optional<mask_t>& value_mask = none) const; + const optional<mask_t>& value_mask = none) const; virtual date_t value_date() const; virtual date_t date() const; @@ -117,7 +117,7 @@ public: } virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); amount_t resolve_expr(scope_t& scope, expr_t& expr); @@ -138,14 +138,14 @@ public: #define POST_EXT_MATCHES 0x0080 #define POST_EXT_CONSIDERED 0x0100 - value_t visited_value; - value_t compound_value; - value_t total; - std::size_t count; - date_t date; - date_t value_date; - datetime_t datetime; - account_t * account; + value_t visited_value; + value_t compound_value; + value_t total; + std::size_t count; + date_t date; + date_t value_date; + datetime_t datetime; + account_t * account; std::list<sort_value_t> sort_values; @@ -155,13 +155,13 @@ public: } xdata_t(const xdata_t& other) : supports_flags<uint_least16_t>(other.flags()), - visited_value(other.visited_value), - compound_value(other.compound_value), - total(other.total), - count(other.count), - date(other.date), - account(other.account), - sort_values(other.sort_values) + visited_value(other.visited_value), + compound_value(other.compound_value), + total(other.total), + count(other.count), + date(other.date), + account(other.account), + sort_values(other.sort_values) { TRACE_CTOR(post_t::xdata_t, "copy"); } @@ -192,14 +192,14 @@ public: } void add_to_value(value_t& value, - const optional<expr_t&>& expr = none) const; + const optional<expr_t&>& expr = none) const; void set_reported_account(account_t * account); account_t * reported_account() { if (xdata_) if (account_t * acct = xdata_->account) - return acct; + return acct; return account; } @@ -213,12 +213,12 @@ public: { bool operator()(const post_t * left, const post_t * right) const { gregorian::date_duration duration = - left->actual_date() - right->actual_date(); + left->actual_date() - right->actual_date(); if (duration.days() == 0) { - return ((left->pos ? left->pos->sequence : 0) < - (right->pos ? right->pos->sequence : 0)); + return ((left->pos ? left->pos->sequence : 0) < + (right->pos ? right->pos->sequence : 0)); } else { - return duration.days() < 0; + return duration.days() < 0; } } }; diff --git a/src/precmd.cc b/src/precmd.cc index e545a783..43a9835c 100644 --- a/src/precmd.cc +++ b/src/precmd.cc @@ -48,27 +48,27 @@ namespace { { string str; { - std::ostringstream buf; + std::ostringstream buf; - buf << "2004/05/27 Book Store\n" - << " ; This note applies to all postings. :SecondTag:\n" - << " Expenses:Books 20 BOOK @ $10\n" - << " ; Metadata: Some Value\n" - << " ; :ExampleTag:\n" - << " ; Here follows a note describing the posting.\n" - << " Liabilities:MasterCard $-200.00\n"; + buf << "2004/05/27 Book Store\n" + << " ; This note applies to all postings. :SecondTag:\n" + << " Expenses:Books 20 BOOK @ $10\n" + << " ; Metadata: Some Value\n" + << " ; :ExampleTag:\n" + << " ; Here follows a note describing the posting.\n" + << " Liabilities:MasterCard $-200.00\n"; - str = buf.str(); + str = buf.str(); } std::ostream& out(report.output_stream); out << _("--- Context is first posting of the following transaction ---") - << std::endl << str << std::endl; + << std::endl << str << std::endl; { - std::istringstream in(str); - report.session.journal->parse(in, report.session); - report.session.journal->clear_xdata(); + std::istringstream in(str); + report.session.journal->parse(in, report.session); + report.session.journal->clear_xdata(); } } xact_t * first = report.session.journal->xacts.front(); @@ -193,7 +193,7 @@ value_t query_command(call_scope_t& args) if (query.tokens_remaining()) { out << std::endl << _("====== Display predicate ======") - << std::endl << std::endl; + << std::endl << std::endl; query.parse_again(); diff --git a/src/predicate.h b/src/predicate.h index c21167d7..fc99c3c6 100644 --- a/src/predicate.h +++ b/src/predicate.h @@ -66,12 +66,12 @@ public: predicate_t(const query_t& other); predicate_t(const string& str, const keep_details_t& _what_to_keep, - const parse_flags_t& flags = PARSE_DEFAULT) + const parse_flags_t& flags = PARSE_DEFAULT) : expr_t(str, flags), what_to_keep(_what_to_keep) { TRACE_CTOR(predicate_t, "string, keep_details_t, parse_flags_t"); } predicate_t(std::istream& in, const keep_details_t& _what_to_keep, - const parse_flags_t& flags = PARSE_DEFAULT) + const parse_flags_t& flags = PARSE_DEFAULT) : expr_t(in, flags), what_to_keep(_what_to_keep) { TRACE_CTOR(predicate_t, "std::istream&, keep_details_t, parse_flags_t"); } @@ -81,10 +81,10 @@ public: virtual value_t real_calc(scope_t& scope) { return (*this ? - expr_t::real_calc(scope) - .strip_annotations(what_to_keep) - .to_boolean() : - true); + expr_t::real_calc(scope) + .strip_annotations(what_to_keep) + .to_boolean() : + true); } #if defined(HAVE_BOOST_SERIALIZATION) diff --git a/src/print.cc b/src/print.cc index 2795c7ad..de35a31d 100644 --- a/src/print.cc +++ b/src/print.cc @@ -41,10 +41,10 @@ namespace ledger { namespace { - void print_note(std::ostream& out, - const string& note, - const std::size_t columns, - const std::size_t prior_width) + void print_note(std::ostream& out, + const string& note, + const std::size_t columns, + const std::size_t prior_width) { // The 4 is for four leading spaces at the beginning of the posting, and // the 3 is for two spaces and a semi-colon before the note. @@ -56,20 +56,20 @@ namespace { bool need_separator = false; for (const char * p = note.c_str(); *p; p++) { if (*p == '\n') { - need_separator = true; + need_separator = true; } else { - if (need_separator) { - out << "\n ;"; - need_separator = false; - } - out << *p; + if (need_separator) { + out << "\n ;"; + need_separator = false; + } + out << *p; } } } void print_xact(report_t& report, std::ostream& out, xact_t& xact) { - format_type_t format_type = FMT_WRITTEN; + format_type_t format_type = FMT_WRITTEN; optional<const char *> format; if (report.HANDLED(date_format_)) { @@ -80,15 +80,15 @@ namespace { std::ostringstream buf; buf << format_date(item_t::use_effective_date ? - xact.date() : xact.actual_date(), - format_type, format); + xact.date() : xact.actual_date(), + format_type, format); if (! item_t::use_effective_date && xact.effective_date()) buf << '=' << format_date(*xact.effective_date(), - format_type, format); + format_type, format); buf << ' '; buf << (xact.state() == item_t::CLEARED ? "* " : - (xact.state() == item_t::PENDING ? "! " : "")); + (xact.state() == item_t::PENDING ? "! " : "")); if (xact.code) buf << '(' << *xact.code << ") "; @@ -99,7 +99,7 @@ namespace { out << leader; std::size_t columns = (report.HANDLED(columns_) ? - report.HANDLER(columns_).value.to_long() : 80); + report.HANDLER(columns_).value.to_long() : 80); if (xact.note) print_note(out, *xact.note, columns, unistring(leader).length()); @@ -107,112 +107,112 @@ namespace { if (xact.metadata) { foreach (const item_t::string_map::value_type& data, *xact.metadata) { - if (! data.second.second) { - out << " ; "; - if (data.second.first) - out << data.first << ": " << *data.second.first; - else - out << ':' << data.first << ":"; - out << '\n'; - } + if (! data.second.second) { + out << " ; "; + if (data.second.first) + out << data.first << ": " << *data.second.first; + else + out << ':' << data.first << ":"; + out << '\n'; + } } } foreach (post_t * post, xact.posts) { if (! report.HANDLED(generated) && - (post->has_flags(ITEM_TEMP | ITEM_GENERATED) && - ! post->has_flags(POST_ANONYMIZED))) - continue; + (post->has_flags(ITEM_TEMP | ITEM_GENERATED) && + ! post->has_flags(POST_ANONYMIZED))) + continue; out << " "; std::ostringstream buf; if (xact.state() == item_t::UNCLEARED) - buf << (post->state() == item_t::CLEARED ? "* " : - (post->state() == item_t::PENDING ? "! " : "")); + buf << (post->state() == item_t::CLEARED ? "* " : + (post->state() == item_t::PENDING ? "! " : "")); if (post->has_flags(POST_VIRTUAL)) { - if (post->has_flags(POST_MUST_BALANCE)) - buf << '['; - else - buf << '('; + if (post->has_flags(POST_MUST_BALANCE)) + buf << '['; + else + buf << '('; } buf << post->account->fullname(); if (post->has_flags(POST_VIRTUAL)) { - if (post->has_flags(POST_MUST_BALANCE)) - buf << ']'; - else - buf << ')'; + if (post->has_flags(POST_MUST_BALANCE)) + buf << ']'; + else + buf << ')'; } unistring name(buf.str()); std::size_t account_width = - (report.HANDLER(account_width_).specified ? - report.HANDLER(account_width_).value.to_long() : 36); + (report.HANDLER(account_width_).specified ? + report.HANDLER(account_width_).value.to_long() : 36); if (account_width < name.length()) - account_width = name.length(); + account_width = name.length(); if (! post->has_flags(POST_CALCULATED) || report.HANDLED(generated)) { - out << name.extract(); - int slip = (static_cast<int>(account_width) - - static_cast<int>(name.length())); - if (slip > 0) { - out.width(slip); - out << ' '; - } - - std::ostringstream amtbuf; - - string amt; - if (post->amount_expr) { - amt = post->amount_expr->text(); - } else { - int amount_width = - (report.HANDLER(amount_width_).specified ? - report.HANDLER(amount_width_).value.to_int() : 12); - - std::ostringstream amt_str; - value_t(post->amount).print(amt_str, amount_width, -1, - AMOUNT_PRINT_RIGHT_JUSTIFY | - AMOUNT_PRINT_NO_COMPUTED_ANNOTATIONS); - amt = amt_str.str(); - } - - string trimmed_amt(amt); - trim_left(trimmed_amt); - int amt_slip = (static_cast<int>(amt.length()) - - static_cast<int>(trimmed_amt.length())); - if (slip + amt_slip < 2) - amtbuf << string(2 - (slip + amt_slip), ' '); - amtbuf << amt; - - if (post->cost && - ! post->has_flags(POST_CALCULATED | POST_COST_CALCULATED)) { - if (post->has_flags(POST_COST_IN_FULL)) - amtbuf << " @@ " << post->cost->abs(); - else - amtbuf << " @ " - << (*post->cost / post->amount).abs(); - } - - if (post->assigned_amount) - amtbuf << " = " << post->assigned_amount; - - string trailer = amtbuf.str(); - out << trailer; - - account_width += unistring(trailer).length(); + out << name.extract(); + int slip = (static_cast<int>(account_width) - + static_cast<int>(name.length())); + if (slip > 0) { + out.width(slip); + out << ' '; + } + + std::ostringstream amtbuf; + + string amt; + if (post->amount_expr) { + amt = post->amount_expr->text(); + } else { + int amount_width = + (report.HANDLER(amount_width_).specified ? + report.HANDLER(amount_width_).value.to_int() : 12); + + std::ostringstream amt_str; + value_t(post->amount).print(amt_str, amount_width, -1, + AMOUNT_PRINT_RIGHT_JUSTIFY | + AMOUNT_PRINT_NO_COMPUTED_ANNOTATIONS); + amt = amt_str.str(); + } + + string trimmed_amt(amt); + trim_left(trimmed_amt); + int amt_slip = (static_cast<int>(amt.length()) - + static_cast<int>(trimmed_amt.length())); + if (slip + amt_slip < 2) + amtbuf << string(2 - (slip + amt_slip), ' '); + amtbuf << amt; + + if (post->cost && + ! post->has_flags(POST_CALCULATED | POST_COST_CALCULATED)) { + if (post->has_flags(POST_COST_IN_FULL)) + amtbuf << " @@ " << post->cost->abs(); + else + amtbuf << " @ " + << (*post->cost / post->amount).abs(); + } + + if (post->assigned_amount) + amtbuf << " = " << post->assigned_amount; + + string trailer = amtbuf.str(); + out << trailer; + + account_width += unistring(trailer).length(); } else { - out << buf.str(); + out << buf.str(); } if (post->note) - print_note(out, *post->note, columns, 4 + account_width); + print_note(out, *post->note, columns, 4 + account_width); out << '\n'; } } diff --git a/src/print.h b/src/print.h index f6ef0868..edfe864d 100644 --- a/src/print.h +++ b/src/print.h @@ -55,14 +55,14 @@ class report_t; class print_xacts : public item_handler<post_t> { protected: - typedef std::list<xact_t *> xacts_list; + typedef std::list<xact_t *> xacts_list; typedef std::map<xact_t *, bool> xacts_present_map; - report_t& report; + report_t& report; xacts_present_map xacts_present; - xacts_list xacts; - bool print_raw; - bool first_title; + xacts_list xacts; + bool print_raw; + bool first_title; public: print_xacts(report_t& _report, bool _print_raw = false) diff --git a/src/pstream.h b/src/pstream.h index bba2845e..5fac20bd 100644 --- a/src/pstream.h +++ b/src/pstream.h @@ -53,44 +53,44 @@ class ptristream : public std::istream ptrinbuf& operator=(const ptrinbuf&); protected: - char * ptr; + char * ptr; std::size_t len; public: ptrinbuf(char * _ptr, std::size_t _len) : ptr(_ptr), len(_len) { if (*ptr && len == 0) - len = std::strlen(ptr); + len = std::strlen(ptr); - setg(ptr, // beginning of putback area - ptr, // read position - ptr+len); // end position + setg(ptr, // beginning of putback area + ptr, // read position + ptr+len); // end position } protected: virtual int_type underflow() { // is read position before end of buffer? if (gptr() < egptr()) - return traits_type::to_int_type(*gptr()); + return traits_type::to_int_type(*gptr()); else - return EOF; + return EOF; } virtual pos_type seekoff(off_type off, ios_base::seekdir way, - ios_base::openmode) + ios_base::openmode) { switch (way) { case std::ios::cur: - setg(ptr, gptr()+off, ptr+len); - break; + setg(ptr, gptr()+off, ptr+len); + break; case std::ios::beg: - setg(ptr, ptr+off, ptr+len); - break; + setg(ptr, ptr+off, ptr+len); + break; case std::ios::end: - setg(ptr, egptr()+off, ptr+len); - break; + setg(ptr, egptr()+off, ptr+len); + break; default: - return pos_type(off_type(-1)); + return pos_type(off_type(-1)); } return pos_type(gptr() - ptr); } diff --git a/src/py_account.cc b/src/py_account.cc index 2b860a24..af51ffce 100644 --- a/src/py_account.cc +++ b/src/py_account.cc @@ -82,7 +82,7 @@ namespace { } account_t * py_find_account_2(journal_t& journal, const string& name, - const bool auto_create) + const bool auto_create) { return journal.find_account(name, auto_create); } @@ -99,14 +99,14 @@ namespace { void export_account() { - scope().attr("ACCOUNT_EXT_SORT_CALC") = ACCOUNT_EXT_SORT_CALC; + scope().attr("ACCOUNT_EXT_SORT_CALC") = ACCOUNT_EXT_SORT_CALC; scope().attr("ACCOUNT_EXT_HAS_NON_VIRTUALS") = ACCOUNT_EXT_HAS_NON_VIRTUALS; scope().attr("ACCOUNT_EXT_HAS_UNB_VIRTUALS") = ACCOUNT_EXT_HAS_UNB_VIRTUALS; scope().attr("ACCOUNT_EXT_AUTO_VIRTUALIZE") = ACCOUNT_EXT_AUTO_VIRTUALIZE; - scope().attr("ACCOUNT_EXT_VISITED") = ACCOUNT_EXT_VISITED; - scope().attr("ACCOUNT_EXT_MATCHING") = ACCOUNT_EXT_MATCHING; + scope().attr("ACCOUNT_EXT_VISITED") = ACCOUNT_EXT_VISITED; + scope().attr("ACCOUNT_EXT_MATCHING") = ACCOUNT_EXT_MATCHING; scope().attr("ACCOUNT_EXT_TO_DISPLAY") = ACCOUNT_EXT_TO_DISPLAY; - scope().attr("ACCOUNT_EXT_DISPLAYED") = ACCOUNT_EXT_DISPLAYED; + scope().attr("ACCOUNT_EXT_DISPLAYED") = ACCOUNT_EXT_DISPLAYED; class_< account_t::xdata_t::details_t > ("AccountXDataDetails") .def_readonly("total", &account_t::xdata_t::details_t::total) @@ -115,30 +115,30 @@ void export_account() .def_readonly("posts_count", &account_t::xdata_t::details_t::posts_count) .def_readonly("posts_virtuals_count", - &account_t::xdata_t::details_t::posts_virtuals_count) + &account_t::xdata_t::details_t::posts_virtuals_count) .def_readonly("posts_cleared_count", - &account_t::xdata_t::details_t::posts_cleared_count) + &account_t::xdata_t::details_t::posts_cleared_count) .def_readonly("posts_last_7_count", - &account_t::xdata_t::details_t::posts_last_7_count) + &account_t::xdata_t::details_t::posts_last_7_count) .def_readonly("posts_last_30_count", - &account_t::xdata_t::details_t::posts_last_30_count) + &account_t::xdata_t::details_t::posts_last_30_count) .def_readonly("posts_this_month_count", - &account_t::xdata_t::details_t::posts_this_month_count) + &account_t::xdata_t::details_t::posts_this_month_count) .def_readonly("earliest_post", - &account_t::xdata_t::details_t::earliest_post) + &account_t::xdata_t::details_t::earliest_post) .def_readonly("earliest_cleared_post", - &account_t::xdata_t::details_t::earliest_cleared_post) + &account_t::xdata_t::details_t::earliest_cleared_post) .def_readonly("latest_post", - &account_t::xdata_t::details_t::latest_post) + &account_t::xdata_t::details_t::latest_post) .def_readonly("latest_cleared_post", - &account_t::xdata_t::details_t::latest_cleared_post) + &account_t::xdata_t::details_t::latest_cleared_post) .def_readonly("filenames", &account_t::xdata_t::details_t::filenames) .def_readonly("accounts_referenced", - &account_t::xdata_t::details_t::accounts_referenced) + &account_t::xdata_t::details_t::accounts_referenced) .def_readonly("payees_referenced", - &account_t::xdata_t::details_t::payees_referenced) + &account_t::xdata_t::details_t::payees_referenced) .def(self += self) @@ -148,8 +148,8 @@ void export_account() class_< account_t::xdata_t > ("AccountXData") #if 1 .add_property("flags", - &supports_flags<uint_least16_t>::flags, - &supports_flags<uint_least16_t>::set_flags) + &supports_flags<uint_least16_t>::flags, + &supports_flags<uint_least16_t>::set_flags) .def("has_flags", &supports_flags<uint_least16_t>::has_flags) .def("clear_flags", &supports_flags<uint_least16_t>::clear_flags) .def("add_flags", &supports_flags<uint_least16_t>::add_flags) @@ -163,14 +163,14 @@ void export_account() ; scope().attr("ACCOUNT_NORMAL") = ACCOUNT_NORMAL; - scope().attr("ACCOUNT_KNOWN") = ACCOUNT_KNOWN; - scope().attr("ACCOUNT_TEMP") = ACCOUNT_TEMP; + scope().attr("ACCOUNT_KNOWN") = ACCOUNT_KNOWN; + scope().attr("ACCOUNT_TEMP") = ACCOUNT_TEMP; class_< account_t > ("Account") #if 1 .add_property("flags", - &supports_flags<>::flags, - &supports_flags<>::set_flags) + &supports_flags<>::flags, + &supports_flags<>::set_flags) .def("has_flags", &supports_flags<>::has_flags) .def("clear_flags", &supports_flags<>::clear_flags) .def("add_flags", &supports_flags<>::add_flags) @@ -178,8 +178,8 @@ void export_account() #endif .add_property("parent", - make_getter(&account_t::parent, - return_internal_reference<>())) + make_getter(&account_t::parent, + return_internal_reference<>())) .def_readwrite("name", &account_t::name) .def_readwrite("note", &account_t::note) @@ -195,9 +195,9 @@ void export_account() .def("remove_account", &account_t::remove_account) .def("find_account", &account_t::find_account, - return_internal_reference<>()) + return_internal_reference<>()) .def("find_account_re", &account_t::find_account, - return_internal_reference<>()) + return_internal_reference<>()) .def("add_post", &account_t::add_post) .def("remove_post", &account_t::remove_post) @@ -208,24 +208,24 @@ void export_account() .def("__getitem__", accounts_getitem, return_internal_reference<>()) .def("__iter__", python::range<return_internal_reference<> > - (&account_t::accounts_begin, &account_t::accounts_end)) + (&account_t::accounts_begin, &account_t::accounts_end)) .def("accounts", python::range<return_internal_reference<> > - (&account_t::accounts_begin, &account_t::accounts_end)) + (&account_t::accounts_begin, &account_t::accounts_end)) .def("posts", python::range<return_internal_reference<> > - (&account_t::posts_begin, &account_t::posts_end)) + (&account_t::posts_begin, &account_t::posts_end)) .def("has_xdata", &account_t::has_xdata) .def("clear_xdata", &account_t::clear_xdata) .def("xdata", py_xdata, - return_internal_reference<>()) + return_internal_reference<>()) .def("amount", &account_t::amount) .def("total", &account_t::total) .def("self_details", &account_t::self_details, - return_internal_reference<>()) + return_internal_reference<>()) .def("family_details", &account_t::family_details, - return_internal_reference<>()) + return_internal_reference<>()) .def("has_xflags", &account_t::has_xflags) .def("children_with_flags", &account_t::children_with_flags) diff --git a/src/py_amount.cc b/src/py_amount.cc index c5962446..3cb9f0eb 100644 --- a/src/py_amount.cc +++ b/src/py_amount.cc @@ -48,12 +48,12 @@ namespace { return amount.value(CURRENT_TIME()); } boost::optional<amount_t> py_value_1(const amount_t& amount, - commodity_t& in_terms_of) { + commodity_t& in_terms_of) { return amount.value(CURRENT_TIME(), in_terms_of); } boost::optional<amount_t> py_value_2(const amount_t& amount, - commodity_t& in_terms_of, - datetime_t& moment) { + commodity_t& in_terms_of, + datetime_t& moment) { return amount.value(moment, in_terms_of); } @@ -63,7 +63,7 @@ namespace { amount.parse(instr, flags); } else { PyErr_SetString(PyExc_IOError, - _("Argument to amount.parse(file) is not a file object")); + _("Argument to amount.parse(file) is not a file object")); } } void py_parse_1(amount_t& amount, object in) { @@ -83,7 +83,7 @@ namespace { amount.print(outstr); } else { PyErr_SetString(PyExc_IOError, - _("Argument to amount.print_(file) is not a file object")); + _("Argument to amount.print_(file) is not a file object")); } } @@ -104,9 +104,9 @@ namespace { } // unnamed namespace -#define EXC_TRANSLATOR(type) \ - void exc_translate_ ## type(const type& err) { \ - PyErr_SetString(PyExc_ArithmeticError, err.what()); \ +#define EXC_TRANSLATOR(type) \ + void exc_translate_ ## type(const type& err) { \ + PyErr_SetString(PyExc_ArithmeticError, err.what()); \ } EXC_TRANSLATOR(amount_error) @@ -120,24 +120,24 @@ void export_amount() .staticmethod("shutdown") .add_static_property("is_initialized", - make_getter(&amount_t::is_initialized), - make_setter(&amount_t::is_initialized)) + make_getter(&amount_t::is_initialized), + make_setter(&amount_t::is_initialized)) .add_static_property("stream_fullstrings", - make_getter(&amount_t::stream_fullstrings), - make_setter(&amount_t::stream_fullstrings)) + make_getter(&amount_t::stream_fullstrings), + make_setter(&amount_t::stream_fullstrings)) .def(init<long>()) .def(init<std::string>()) .def("exact", &amount_t::exact, args("value"), - _("Construct an amount object whose display precision is always equal to its\n\ + _("Construct an amount object whose display precision is always equal to its\n\ internal precision.")) .staticmethod("exact") .def(init<amount_t>()) .def("compare", &amount_t::compare, args("amount"), - _("Compare two amounts for equality, returning <0, 0 or >0.")) + _("Compare two amounts for equality, returning <0, 0 or >0.")) .def(self == self) .def(self == long()) @@ -168,40 +168,40 @@ internal precision.")) .def(self += self) .def(self += long()) - .def(self + self) - .def(self + long()) - .def(long() + self) + .def(self + self) + .def(self + long()) + .def(long() + self) .def(self -= self) .def(self -= long()) - .def(self - self) - .def(self - long()) - .def(long() - self) + .def(self - self) + .def(self - long()) + .def(long() - self) .def(self *= self) .def(self *= long()) - .def(self * self) - .def(self * long()) - .def(long() * self) + .def(self * self) + .def(self * long()) + .def(long() * self) .def(self /= self) .def(self /= long()) - .def(self / self) - .def(self / long()) - .def(long() / self) + .def(self / self) + .def(self / long()) + .def(long() / self) .add_property("precision", &amount_t::precision) .add_property("display_precision", &amount_t::display_precision) .add_property("keep_precision", - &amount_t::keep_precision, - &amount_t::set_keep_precision) + &amount_t::keep_precision, + &amount_t::set_keep_precision) .def("negated", &amount_t::negated) .def("in_place_negate", &amount_t::in_place_negate, - return_internal_reference<>()) + return_internal_reference<>()) .def(- self) .def("abs", &amount_t::abs) @@ -211,27 +211,27 @@ internal precision.")) .def("rounded", &amount_t::rounded) .def("in_place_round", &amount_t::in_place_round, - return_internal_reference<>()) + return_internal_reference<>()) .def("truncated", &amount_t::truncated) .def("in_place_truncate", &amount_t::in_place_truncate, - return_internal_reference<>()) + return_internal_reference<>()) .def("floored", &amount_t::floored) .def("in_place_floor", &amount_t::in_place_floor, - return_internal_reference<>()) + return_internal_reference<>()) .def("unrounded", &amount_t::unrounded) .def("in_place_unround", &amount_t::in_place_unround, - return_internal_reference<>()) + return_internal_reference<>()) .def("reduced", &amount_t::reduced) .def("in_place_reduce", &amount_t::in_place_reduce, - return_internal_reference<>()) + return_internal_reference<>()) .def("unreduced", &amount_t::unreduced) .def("in_place_unreduce", &amount_t::in_place_unreduce, - return_internal_reference<>()) + return_internal_reference<>()) .def("value", py_value_0) .def("value", py_value_1, args("in_terms_of")) @@ -260,10 +260,10 @@ internal precision.")) .def("quantity_string", &amount_t::quantity_string) .add_property("commodity", - make_function(&amount_t::commodity, - return_value_policy<reference_existing_object>()), - make_function(&amount_t::set_commodity, - with_custodian_and_ward<1, 2>())) + make_function(&amount_t::commodity, + return_value_policy<reference_existing_object>()), + make_function(&amount_t::set_commodity, + with_custodian_and_ward<1, 2>())) .def("has_commodity", &amount_t::has_commodity) .def("clear_commodity", &amount_t::clear_commodity) @@ -272,8 +272,8 @@ internal precision.")) .def("annotate", &amount_t::annotate) .def("has_annotation", &amount_t::has_annotation) .add_property("annotation", - make_function(py_amount_annotation, - return_internal_reference<>())) + make_function(py_amount_annotation, + return_internal_reference<>())) .def("strip_annotations", py_strip_annotations_0) .def("strip_annotations", py_strip_annotations_1) diff --git a/src/py_balance.cc b/src/py_balance.cc index 03a73ff6..eba5761d 100644 --- a/src/py_balance.cc +++ b/src/py_balance.cc @@ -48,12 +48,12 @@ namespace { return balance.value(CURRENT_TIME()); } boost::optional<balance_t> py_value_1(const balance_t& balance, - commodity_t& in_terms_of) { + commodity_t& in_terms_of) { return balance.value(CURRENT_TIME(), in_terms_of); } boost::optional<balance_t> py_value_2(const balance_t& balance, - commodity_t& in_terms_of, - datetime_t& moment) { + commodity_t& in_terms_of, + datetime_t& moment) { return balance.value(moment, in_terms_of); } @@ -64,7 +64,7 @@ namespace { boost::optional<amount_t> py_commodity_amount_1(const balance_t& balance, - const boost::optional<const commodity_t&>& commodity) { + const boost::optional<const commodity_t&>& commodity) { return balance.commodity_amount(commodity); } @@ -74,7 +74,7 @@ namespace { balance.print(outstr); } else { PyErr_SetString(PyExc_IOError, - _("Argument to balance.print_(file) is not a file object")); + _("Argument to balance.print_(file) is not a file object")); } } @@ -111,9 +111,9 @@ namespace { } // unnamed namespace -#define EXC_TRANSLATOR(type) \ - void exc_translate_ ## type(const type& err) { \ - PyErr_SetString(PyExc_ArithmeticError, err.what()); \ +#define EXC_TRANSLATOR(type) \ + void exc_translate_ ## type(const type& err) { \ + PyErr_SetString(PyExc_ArithmeticError, err.what()); \ } EXC_TRANSLATOR(balance_error) @@ -162,7 +162,7 @@ void export_balance() .def("negated", &balance_t::negated) .def("in_place_negate", &balance_t::in_place_negate, - return_internal_reference<>()) + return_internal_reference<>()) .def(- self) .def("abs", &balance_t::abs) @@ -173,27 +173,27 @@ void export_balance() .def("rounded", &balance_t::rounded) .def("in_place_round", &balance_t::in_place_round, - return_internal_reference<>()) + return_internal_reference<>()) .def("truncated", &balance_t::truncated) .def("in_place_truncate", &balance_t::in_place_truncate, - return_internal_reference<>()) + return_internal_reference<>()) .def("floored", &balance_t::floored) .def("in_place_floor", &balance_t::in_place_floor, - return_internal_reference<>()) + return_internal_reference<>()) .def("unrounded", &balance_t::unrounded) .def("in_place_unround", &balance_t::in_place_unround, - return_internal_reference<>()) + return_internal_reference<>()) .def("reduced", &balance_t::reduced) .def("in_place_reduce", &balance_t::in_place_reduce, - return_internal_reference<>()) + return_internal_reference<>()) .def("unreduced", &balance_t::unreduced) .def("in_place_unreduce", &balance_t::in_place_unreduce, - return_internal_reference<>()) + return_internal_reference<>()) .def("value", py_value_0) .def("value", py_value_1, args("in_terms_of")) diff --git a/src/py_commodity.cc b/src/py_commodity.cc index fc7e8c3e..783171dd 100644 --- a/src/py_commodity.cc +++ b/src/py_commodity.cc @@ -44,38 +44,38 @@ using namespace boost::python; namespace { commodity_t * py_create_1(commodity_pool_t& pool, - const string& symbol) + const string& symbol) { return pool.create(symbol); } - commodity_t * py_create_2(commodity_pool_t& pool, - const string& symbol, - const annotation_t& details) + commodity_t * py_create_2(commodity_pool_t& pool, + const string& symbol, + const annotation_t& details) { return pool.create(symbol, details); } commodity_t * py_find_or_create_1(commodity_pool_t& pool, - const string& symbol) + const string& symbol) { return pool.find_or_create(symbol); } - commodity_t * py_find_or_create_2(commodity_pool_t& pool, - const string& symbol, - const annotation_t& details) + commodity_t * py_find_or_create_2(commodity_pool_t& pool, + const string& symbol, + const annotation_t& details) { return pool.find_or_create(symbol, details); } commodity_t * py_find_1(commodity_pool_t& pool, - const string& name) + const string& name) { return pool.find(name); } commodity_t * py_find_2(commodity_pool_t& pool, - const string& symbol, - const annotation_t& details) + const string& symbol, + const annotation_t& details) { return pool.find(symbol, details); } @@ -83,25 +83,25 @@ namespace { // Exchange one commodity for another, while recording the factored price. void py_exchange_2(commodity_pool_t& pool, - commodity_t& commodity, - const amount_t& per_unit_cost) + commodity_t& commodity, + const amount_t& per_unit_cost) { pool.exchange(commodity, per_unit_cost, CURRENT_TIME()); } void py_exchange_3(commodity_pool_t& pool, - commodity_t& commodity, - const amount_t& per_unit_cost, - const datetime_t& moment) + commodity_t& commodity, + const amount_t& per_unit_cost, + const datetime_t& moment) { pool.exchange(commodity, per_unit_cost, moment); } - cost_breakdown_t py_exchange_5(commodity_pool_t& pool, - const amount_t& amount, - const amount_t& cost, - const bool is_per_unit, - const boost::optional<datetime_t>& moment, - const boost::optional<string>& tag) + cost_breakdown_t py_exchange_5(commodity_pool_t& pool, + const amount_t& amount, + const amount_t& cost, + const bool is_per_unit, + const boost::optional<datetime_t>& moment, + const boost::optional<string>& tag) { return pool.exchange(amount, cost, is_per_unit, moment, tag); } @@ -112,7 +112,7 @@ namespace { pool.commodities.find(symbol); if (i == pool.commodities.end()) { PyErr_SetString(PyExc_ValueError, - (string("Could not find commodity ") + symbol).c_str()); + (string("Could not find commodity ") + symbol).c_str()); throw boost::python::error_already_set(); } return (*i).second; @@ -178,12 +178,12 @@ namespace { } void py_add_price_2(commodity_t& commodity, - const datetime_t& date, const amount_t& price) { + const datetime_t& date, const amount_t& price) { commodity.add_price(date, price); } void py_add_price_3(commodity_t& commodity, const datetime_t& date, - const amount_t& price, const bool reflexive) { + const amount_t& price, const bool reflexive) { commodity.add_price(date, price, reflexive); } @@ -212,7 +212,7 @@ namespace { return comm.strip_annotations(keep_details_t()); } commodity_t& py_strip_annotations_1(commodity_t& comm, - const keep_details_t& keep) { + const keep_details_t& keep) { return comm.strip_annotations(keep); } @@ -220,7 +220,7 @@ namespace { return comm.strip_annotations(keep_details_t()); } commodity_t& py_strip_ann_annotations_1(annotated_commodity_t& comm, - const keep_details_t& keep) { + const keep_details_t& keep) { return comm.strip_annotations(keep); } @@ -228,7 +228,7 @@ namespace { return ann.price; } boost::optional<amount_t> py_set_price(annotation_t& ann, - const boost::optional<amount_t>& price) { + const boost::optional<amount_t>& price) { return ann.price = price; } @@ -243,41 +243,41 @@ void export_commodity() class_< commodity_pool_t, shared_ptr<commodity_pool_t>, boost::noncopyable > ("CommodityPool", no_init) .add_property("null_commodity", - make_getter(&commodity_pool_t::null_commodity, - return_internal_reference<>())) + make_getter(&commodity_pool_t::null_commodity, + return_internal_reference<>())) .add_property("default_commodity", - make_getter(&commodity_pool_t::default_commodity, - return_internal_reference<>()), - make_setter(&commodity_pool_t::default_commodity, - with_custodian_and_ward<1, 2>())) + make_getter(&commodity_pool_t::default_commodity, + return_internal_reference<>()), + make_setter(&commodity_pool_t::default_commodity, + with_custodian_and_ward<1, 2>())) .add_property("keep_base", - make_getter(&commodity_pool_t::keep_base), - make_setter(&commodity_pool_t::keep_base)) + make_getter(&commodity_pool_t::keep_base), + make_setter(&commodity_pool_t::keep_base)) .add_property("price_db", - make_getter(&commodity_pool_t::price_db), - make_setter(&commodity_pool_t::price_db)) + make_getter(&commodity_pool_t::price_db), + make_setter(&commodity_pool_t::price_db)) .add_property("quote_leeway", - make_getter(&commodity_pool_t::quote_leeway), - make_setter(&commodity_pool_t::quote_leeway)) + make_getter(&commodity_pool_t::quote_leeway), + make_setter(&commodity_pool_t::quote_leeway)) .add_property("get_quotes", - make_getter(&commodity_pool_t::get_quotes), - make_setter(&commodity_pool_t::get_quotes)) + make_getter(&commodity_pool_t::get_quotes), + make_setter(&commodity_pool_t::get_quotes)) .add_property("get_commodity_quote", - make_getter(&commodity_pool_t::get_commodity_quote), - make_setter(&commodity_pool_t::get_commodity_quote)) + make_getter(&commodity_pool_t::get_commodity_quote), + make_setter(&commodity_pool_t::get_commodity_quote)) .def("make_qualified_name", &commodity_pool_t::make_qualified_name) .def("create", py_create_1, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("create", py_create_2, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("find_or_create", py_find_or_create_1, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("find_or_create", py_find_or_create_2, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("find", py_find_1, return_value_policy<reference_existing_object>()) .def("find", py_find_2, return_value_policy<reference_existing_object>()) @@ -288,46 +288,46 @@ void export_commodity() .def("parse_price_directive", &commodity_pool_t::parse_price_directive) .def("parse_price_expression", &commodity_pool_t::parse_price_expression, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("__getitem__", py_pool_getitem, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("keys", py_pool_keys) .def("has_key", py_pool_contains) .def("__contains__", py_pool_contains) .def("__iter__", - python::range<return_value_policy<reference_existing_object> > - (py_pool_commodities_begin, py_pool_commodities_end)) + python::range<return_value_policy<reference_existing_object> > + (py_pool_commodities_begin, py_pool_commodities_end)) .def("iteritems", - python::range<return_value_policy<reference_existing_object> > - (py_pool_commodities_begin, py_pool_commodities_end)) + python::range<return_value_policy<reference_existing_object> > + (py_pool_commodities_begin, py_pool_commodities_end)) .def("iterkeys", python::range<>(py_pool_commodities_keys_begin, - py_pool_commodities_keys_end)) + py_pool_commodities_keys_end)) .def("itervalues", - python::range<return_value_policy<reference_existing_object> > - (py_pool_commodities_values_begin, py_pool_commodities_values_end)) + python::range<return_value_policy<reference_existing_object> > + (py_pool_commodities_values_begin, py_pool_commodities_values_end)) ; map_value_type_converter<commodity_pool_t::commodities_map>(); scope().attr("commodities") = commodity_pool_t::current_pool; - scope().attr("COMMODITY_STYLE_DEFAULTS") = COMMODITY_STYLE_DEFAULTS; - scope().attr("COMMODITY_STYLE_SUFFIXED") = COMMODITY_STYLE_SUFFIXED; - scope().attr("COMMODITY_STYLE_SEPARATED") = COMMODITY_STYLE_SEPARATED; + scope().attr("COMMODITY_STYLE_DEFAULTS") = COMMODITY_STYLE_DEFAULTS; + scope().attr("COMMODITY_STYLE_SUFFIXED") = COMMODITY_STYLE_SUFFIXED; + scope().attr("COMMODITY_STYLE_SEPARATED") = COMMODITY_STYLE_SEPARATED; scope().attr("COMMODITY_STYLE_DECIMAL_COMMA") = COMMODITY_STYLE_DECIMAL_COMMA; - scope().attr("COMMODITY_STYLE_THOUSANDS") = COMMODITY_STYLE_THOUSANDS; - scope().attr("COMMODITY_NOMARKET") = COMMODITY_NOMARKET; - scope().attr("COMMODITY_BUILTIN") = COMMODITY_BUILTIN; - scope().attr("COMMODITY_WALKED") = COMMODITY_WALKED; - scope().attr("COMMODITY_KNOWN") = COMMODITY_KNOWN; - scope().attr("COMMODITY_PRIMARY") = COMMODITY_PRIMARY; + scope().attr("COMMODITY_STYLE_THOUSANDS") = COMMODITY_STYLE_THOUSANDS; + scope().attr("COMMODITY_NOMARKET") = COMMODITY_NOMARKET; + scope().attr("COMMODITY_BUILTIN") = COMMODITY_BUILTIN; + scope().attr("COMMODITY_WALKED") = COMMODITY_WALKED; + scope().attr("COMMODITY_KNOWN") = COMMODITY_KNOWN; + scope().attr("COMMODITY_PRIMARY") = COMMODITY_PRIMARY; class_< commodity_t, boost::noncopyable > ("Commodity", no_init) #if 1 .add_property("flags", - &supports_flags<uint_least16_t>::flags, - &supports_flags<uint_least16_t>::set_flags) + &supports_flags<uint_least16_t>::flags, + &supports_flags<uint_least16_t>::set_flags) .def("has_flags", &delegates_flags<uint_least16_t>::has_flags) .def("clear_flags", &delegates_flags<uint_least16_t>::clear_flags) .def("add_flags", &delegates_flags<uint_least16_t>::add_flags) @@ -335,8 +335,8 @@ void export_commodity() #endif .add_static_property("decimal_comma_by_default", - make_getter(&commodity_t::decimal_comma_by_default), - make_setter(&commodity_t::decimal_comma_by_default)) + make_getter(&commodity_t::decimal_comma_by_default), + make_setter(&commodity_t::decimal_comma_by_default)) .def("__str__", &commodity_t::symbol) .def("__unicode__", py_commodity_unicode) @@ -348,18 +348,18 @@ void export_commodity() .staticmethod("symbol_needs_quotes") .add_property("referent", - make_function(py_commodity_referent, - return_value_policy<reference_existing_object>())) + make_function(py_commodity_referent, + return_value_policy<reference_existing_object>())) .def("has_annotation", &commodity_t::has_annotation) .def("strip_annotations", py_strip_annotations_0, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("strip_annotations", py_strip_annotations_1, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("write_annotations", &commodity_t::write_annotations) .def("pool", &commodity_t::pool, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .add_property("base_symbol", &commodity_t::base_symbol) .add_property("symbol", &commodity_t::symbol) @@ -368,14 +368,14 @@ void export_commodity() .add_property("name", &commodity_t::name, &commodity_t::set_name) .add_property("note", &commodity_t::note, &commodity_t::set_note) .add_property("precision", &commodity_t::precision, - &commodity_t::set_precision) + &commodity_t::set_precision) .add_property("smaller", &commodity_t::smaller, &commodity_t::set_smaller) .add_property("larger", &commodity_t::larger, &commodity_t::set_larger) .def("add_price", py_add_price_2) .def("add_price", py_add_price_3) .def("remove_price", &commodity_t::remove_price, - with_custodian_and_ward<1, 3>()) + with_custodian_and_ward<1, 3>()) .def("find_price", &commodity_t::find_price) .def("check_for_updated_price", &commodity_t::check_for_updated_price) @@ -385,7 +385,7 @@ void export_commodity() class_< annotation_t > ("Annotation", no_init) #if 1 .add_property("flags", &supports_flags<>::flags, - &supports_flags<>::set_flags) + &supports_flags<>::set_flags) .def("has_flags", &supports_flags<>::has_flags) .def("clear_flags", &supports_flags<>::clear_flags) .def("add_flags", &supports_flags<>::add_flags) @@ -394,11 +394,11 @@ void export_commodity() .add_property("price", py_price, py_set_price) .add_property("date", - make_getter(&annotation_t::date), - make_setter(&annotation_t::date)) + make_getter(&annotation_t::date), + make_setter(&annotation_t::date)) .add_property("tag", - make_getter(&annotation_t::tag), - make_setter(&annotation_t::tag)) + make_getter(&annotation_t::tag), + make_setter(&annotation_t::tag)) .def("__nonzero__", &annotation_t::operator bool) @@ -411,17 +411,17 @@ void export_commodity() .def(init<bool, bool, bool, bool>()) .add_property("keep_price", - make_getter(&keep_details_t::keep_price), - make_setter(&keep_details_t::keep_price)) + make_getter(&keep_details_t::keep_price), + make_setter(&keep_details_t::keep_price)) .add_property("keep_date", - make_getter(&keep_details_t::keep_date), - make_setter(&keep_details_t::keep_date)) + make_getter(&keep_details_t::keep_date), + make_setter(&keep_details_t::keep_date)) .add_property("keep_tag", - make_getter(&keep_details_t::keep_tag), - make_setter(&keep_details_t::keep_tag)) + make_getter(&keep_details_t::keep_tag), + make_setter(&keep_details_t::keep_tag)) .add_property("only_actuals", - make_getter(&keep_details_t::only_actuals), - make_setter(&keep_details_t::only_actuals)) + make_getter(&keep_details_t::only_actuals), + make_setter(&keep_details_t::only_actuals)) .def("keep_all", py_keep_all_0) .def("keep_all", py_keep_all_1) @@ -433,20 +433,20 @@ void export_commodity() annotated_commodity_t, boost::noncopyable > ("AnnotatedCommodity", no_init) .add_property("details", - make_getter(&annotated_commodity_t::details), - make_setter(&annotated_commodity_t::details)) + make_getter(&annotated_commodity_t::details), + make_setter(&annotated_commodity_t::details)) .def(self == self) .def(self == other<commodity_t>()) .add_property("referent", - make_function(py_annotated_commodity_referent, - return_value_policy<reference_existing_object>())) + make_function(py_annotated_commodity_referent, + return_value_policy<reference_existing_object>())) .def("strip_annotations", py_strip_ann_annotations_0, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("strip_annotations", py_strip_ann_annotations_1, - return_value_policy<reference_existing_object>()) + return_value_policy<reference_existing_object>()) .def("write_annotations", &annotated_commodity_t::write_annotations) ; } diff --git a/src/py_format.cc b/src/py_format.cc index 36f89ae5..ce7052ac 100644 --- a/src/py_format.cc +++ b/src/py_format.cc @@ -37,9 +37,9 @@ namespace ledger { using namespace boost::python; -#define EXC_TRANSLATOR(type) \ - void exc_translate_ ## type(const type& err) { \ - PyErr_SetString(PyExc_ArithmeticError, err.what()); \ +#define EXC_TRANSLATOR(type) \ + void exc_translate_ ## type(const type& err) { \ + PyErr_SetString(PyExc_ArithmeticError, err.what()); \ } //EXC_TRANSLATOR(format_error) diff --git a/src/py_item.cc b/src/py_item.cc index edebd532..65d89119 100644 --- a/src/py_item.cc +++ b/src/py_item.cc @@ -49,7 +49,7 @@ namespace { return item.has_tag(tag_mask); } bool py_has_tag_2m(item_t& item, const mask_t& tag_mask, - const boost::optional<mask_t>& value_mask) { + const boost::optional<mask_t>& value_mask) { return item.has_tag(tag_mask, value_mask); } @@ -60,15 +60,15 @@ namespace { return item.get_tag(tag_mask); } boost::optional<string> py_get_tag_2m(item_t& item, const mask_t& tag_mask, - const boost::optional<mask_t>& value_mask) { + const boost::optional<mask_t>& value_mask) { return item.get_tag(tag_mask, value_mask); } } // unnamed namespace -#define EXC_TRANSLATOR(type) \ - void exc_translate_ ## type(const type& err) { \ - PyErr_SetString(PyExc_ArithmeticError, err.what()); \ +#define EXC_TRANSLATOR(type) \ + void exc_translate_ ## type(const type& err) { \ + PyErr_SetString(PyExc_ArithmeticError, err.what()); \ } //EXC_TRANSLATOR(item_error) @@ -77,25 +77,25 @@ void export_item() { class_< position_t > ("Position") .add_property("pathname", - make_getter(&position_t::pathname), - make_setter(&position_t::pathname)) + make_getter(&position_t::pathname), + make_setter(&position_t::pathname)) .add_property("beg_pos", - make_getter(&position_t::beg_pos), - make_setter(&position_t::beg_pos)) + make_getter(&position_t::beg_pos), + make_setter(&position_t::beg_pos)) .add_property("beg_line", - make_getter(&position_t::beg_line), - make_setter(&position_t::beg_line)) + make_getter(&position_t::beg_line), + make_setter(&position_t::beg_line)) .add_property("end_pos", - make_getter(&position_t::end_pos), - make_setter(&position_t::end_pos)) + make_getter(&position_t::end_pos), + make_setter(&position_t::end_pos)) .add_property("end_line", - make_getter(&position_t::end_line), - make_setter(&position_t::end_line)) + make_getter(&position_t::end_line), + make_setter(&position_t::end_line)) ; - scope().attr("ITEM_NORMAL") = ITEM_NORMAL; + scope().attr("ITEM_NORMAL") = ITEM_NORMAL; scope().attr("ITEM_GENERATED") = ITEM_GENERATED; - scope().attr("ITEM_TEMP") = ITEM_TEMP; + scope().attr("ITEM_TEMP") = ITEM_TEMP; enum_< item_t::state_t > ("State") .value("Uncleared", item_t::UNCLEARED) @@ -110,7 +110,7 @@ void export_item() #endif #if 1 .add_property("flags", &supports_flags<>::flags, - &supports_flags<>::set_flags) + &supports_flags<>::set_flags) .def("has_flags", &supports_flags<>::has_flags) .def("clear_flags", &supports_flags<>::clear_flags) .def("add_flags", &supports_flags<>::add_flags) @@ -118,14 +118,14 @@ void export_item() #endif .add_property("note", - make_getter(&item_t::note), - make_setter(&item_t::note)) + make_getter(&item_t::note), + make_setter(&item_t::note)) .add_property("pos", - make_getter(&item_t::pos), - make_setter(&item_t::pos)) + make_getter(&item_t::pos), + make_setter(&item_t::pos)) .add_property("metadata", - make_getter(&item_t::metadata), - make_setter(&item_t::metadata)) + make_getter(&item_t::metadata), + make_setter(&item_t::metadata)) .def("copy_details", &item_t::copy_details) @@ -148,12 +148,12 @@ void export_item() .def("append_note", &item_t::append_note) .add_static_property("use_effective_date", - make_getter(&item_t::use_effective_date), - make_setter(&item_t::use_effective_date)) + make_getter(&item_t::use_effective_date), + make_setter(&item_t::use_effective_date)) .add_property("date", &item_t::date, make_setter(&item_t::_date)) .add_property("effective_date", &item_t::effective_date, - make_setter(&item_t::_date_eff)) + make_setter(&item_t::_date_eff)) .add_property("state", &item_t::state, &item_t::set_state) diff --git a/src/py_journal.cc b/src/py_journal.cc index cd25d134..fc4f671b 100644 --- a/src/py_journal.cc +++ b/src/py_journal.cc @@ -126,7 +126,7 @@ namespace { } account_t * py_find_account_2(journal_t& journal, const string& name, - const bool auto_create) + const bool auto_create) { return journal.find_account(name, auto_create); } @@ -138,14 +138,14 @@ namespace { struct collector_wrapper { - journal_t& journal; + journal_t& journal; report_t report; collect_posts * posts_collector; post_handler_ptr chain; collector_wrapper(journal_t& _journal, report_t& base) : journal(_journal), report(base), - posts_collector(new collect_posts) {} + posts_collector(new collect_posts) {} ~collector_wrapper() { journal.clear_xdata(); } @@ -167,31 +167,31 @@ namespace { { if (journal.has_xdata()) { PyErr_SetString(PyExc_RuntimeError, - _("Cannot have multiple journal collections open at once")); + _("Cannot have multiple journal collections open at once")); throw_error_already_set(); } report_t& current_report(downcast<report_t>(*scope_t::default_scope)); shared_ptr<collector_wrapper> coll(new collector_wrapper(journal, - current_report)); + current_report)); std::auto_ptr<journal_t> save_journal (current_report.session.journal.release()); current_report.session.journal.reset(&journal); try { strings_list remaining = - process_arguments(split_arguments(query.c_str()), coll->report); + process_arguments(split_arguments(query.c_str()), coll->report); coll->report.normalize_options("register"); value_t args; foreach (const string& arg, remaining) - args.push_back(string_value(arg)); + args.push_back(string_value(arg)); coll->report.parse_query_args(args, "@Journal.collect"); journal_posts_iterator walker(coll->journal); coll->chain = - chain_post_handlers(post_handler_ptr(coll->posts_collector), - coll->report); + chain_post_handlers(post_handler_ptr(coll->posts_collector), + coll->report); pass_down_posts(coll->chain, walker); } catch (...) { @@ -227,36 +227,36 @@ void export_journal() shared_ptr<collect_posts>, boost::noncopyable >("PostCollector") .def("__len__", &collect_posts::length) .def("__iter__", python::range<return_internal_reference<1, - with_custodian_and_ward_postcall<1, 0> > > - (&collect_posts::begin, &collect_posts::end)) + with_custodian_and_ward_postcall<1, 0> > > + (&collect_posts::begin, &collect_posts::end)) ; class_< collector_wrapper, shared_ptr<collector_wrapper>, boost::noncopyable >("PostCollectorWrapper", no_init) .def("__len__", &collector_wrapper::length) .def("__getitem__", posts_getitem, return_internal_reference<1, - with_custodian_and_ward_postcall<0, 1> >()) + with_custodian_and_ward_postcall<0, 1> >()) .def("__iter__", - python::range<return_value_policy<reference_existing_object, - with_custodian_and_ward_postcall<0, 1> > > - (&collector_wrapper::begin, &collector_wrapper::end)) + python::range<return_value_policy<reference_existing_object, + with_custodian_and_ward_postcall<0, 1> > > + (&collector_wrapper::begin, &collector_wrapper::end)) ; class_< journal_t::fileinfo_t > ("FileInfo") .def(init<path>()) .add_property("filename", - make_getter(&journal_t::fileinfo_t::filename), - make_setter(&journal_t::fileinfo_t::filename)) + make_getter(&journal_t::fileinfo_t::filename), + make_setter(&journal_t::fileinfo_t::filename)) .add_property("size", - make_getter(&journal_t::fileinfo_t::size), - make_setter(&journal_t::fileinfo_t::size)) + make_getter(&journal_t::fileinfo_t::size), + make_setter(&journal_t::fileinfo_t::size)) .add_property("modtime", - make_getter(&journal_t::fileinfo_t::modtime), - make_setter(&journal_t::fileinfo_t::modtime)) + make_getter(&journal_t::fileinfo_t::modtime), + make_setter(&journal_t::fileinfo_t::modtime)) .add_property("from_stream", - make_getter(&journal_t::fileinfo_t::from_stream), - make_setter(&journal_t::fileinfo_t::from_stream)) + make_getter(&journal_t::fileinfo_t::from_stream), + make_setter(&journal_t::fileinfo_t::from_stream)) ; class_< journal_t, boost::noncopyable > ("Journal") @@ -264,28 +264,28 @@ void export_journal() .def(init<string>()) .add_property("master", - make_getter(&journal_t::master, - return_internal_reference<1, - with_custodian_and_ward_postcall<1, 0> >())) + make_getter(&journal_t::master, + return_internal_reference<1, + with_custodian_and_ward_postcall<1, 0> >())) .add_property("bucket", - make_getter(&journal_t::bucket, - return_internal_reference<1, - with_custodian_and_ward_postcall<1, 0> >()), - make_setter(&journal_t::bucket)) + make_getter(&journal_t::bucket, + return_internal_reference<1, + with_custodian_and_ward_postcall<1, 0> >()), + make_setter(&journal_t::bucket)) .add_property("was_loaded", make_getter(&journal_t::was_loaded)) .def("add_account", &journal_t::add_account) .def("remove_account", &journal_t::remove_account) .def("find_account", py_find_account_1, - return_internal_reference<1, - with_custodian_and_ward_postcall<0, 1> >()) + return_internal_reference<1, + with_custodian_and_ward_postcall<0, 1> >()) .def("find_account", py_find_account_2, - return_internal_reference<1, - with_custodian_and_ward_postcall<0, 1> >()) + return_internal_reference<1, + with_custodian_and_ward_postcall<0, 1> >()) .def("find_account_re", &journal_t::find_account_re, - return_internal_reference<1, - with_custodian_and_ward_postcall<0, 1> >()) + return_internal_reference<1, + with_custodian_and_ward_postcall<0, 1> >()) .def("add_xact", &journal_t::add_xact) .def("remove_xact", &journal_t::remove_xact) @@ -293,20 +293,20 @@ void export_journal() .def("__len__", xacts_len) #if 0 .def("__getitem__", xacts_getitem, - return_internal_reference<1, - with_custodian_and_ward_postcall<0, 1> >()) + return_internal_reference<1, + with_custodian_and_ward_postcall<0, 1> >()) #endif .def("__iter__", python::range<return_internal_reference<> > - (&journal_t::xacts_begin, &journal_t::xacts_end)) + (&journal_t::xacts_begin, &journal_t::xacts_end)) .def("xacts", python::range<return_internal_reference<> > - (&journal_t::xacts_begin, &journal_t::xacts_end)) + (&journal_t::xacts_begin, &journal_t::xacts_end)) .def("auto_xacts", python::range<return_internal_reference<> > - (&journal_t::auto_xacts_begin, &journal_t::auto_xacts_end)) + (&journal_t::auto_xacts_begin, &journal_t::auto_xacts_end)) .def("period_xacts", python::range<return_internal_reference<> > - (&journal_t::period_xacts_begin, &journal_t::period_xacts_end)) + (&journal_t::period_xacts_begin, &journal_t::period_xacts_end)) .def("sources", python::range<return_internal_reference<> > - (&journal_t::sources_begin, &journal_t::sources_end)) + (&journal_t::sources_begin, &journal_t::sources_end)) .def("read", py_read) diff --git a/src/py_post.cc b/src/py_post.cc index e4a50980..930a46c9 100644 --- a/src/py_post.cc +++ b/src/py_post.cc @@ -48,7 +48,7 @@ namespace { return post.has_tag(tag_mask); } bool py_has_tag_2m(post_t& post, const mask_t& tag_mask, - const boost::optional<mask_t>& value_mask) { + const boost::optional<mask_t>& value_mask) { return post.has_tag(tag_mask, value_mask); } @@ -59,7 +59,7 @@ namespace { return post.get_tag(tag_mask); } boost::optional<string> py_get_tag_2m(post_t& post, const mask_t& tag_mask, - const boost::optional<mask_t>& value_mask) { + const boost::optional<mask_t>& value_mask) { return post.get_tag(tag_mask, value_mask); } @@ -88,8 +88,8 @@ void export_post() class_< post_t::xdata_t > ("PostingXData") #if 1 .add_property("flags", - &supports_flags<uint_least16_t>::flags, - &supports_flags<uint_least16_t>::set_flags) + &supports_flags<uint_least16_t>::flags, + &supports_flags<uint_least16_t>::set_flags) .def("has_flags", &supports_flags<uint_least16_t>::has_flags) .def("clear_flags", &supports_flags<uint_least16_t>::clear_flags) .def("add_flags", &supports_flags<uint_least16_t>::add_flags) @@ -97,34 +97,34 @@ void export_post() #endif .add_property("visited_value", - make_getter(&post_t::xdata_t::visited_value), - make_setter(&post_t::xdata_t::visited_value)) + make_getter(&post_t::xdata_t::visited_value), + make_setter(&post_t::xdata_t::visited_value)) .add_property("compound_value", - make_getter(&post_t::xdata_t::compound_value), - make_setter(&post_t::xdata_t::compound_value)) + make_getter(&post_t::xdata_t::compound_value), + make_setter(&post_t::xdata_t::compound_value)) .add_property("total", - make_getter(&post_t::xdata_t::total), - make_setter(&post_t::xdata_t::total)) + make_getter(&post_t::xdata_t::total), + make_setter(&post_t::xdata_t::total)) .add_property("count", - make_getter(&post_t::xdata_t::count), - make_setter(&post_t::xdata_t::count)) + make_getter(&post_t::xdata_t::count), + make_setter(&post_t::xdata_t::count)) .add_property("date", - make_getter(&post_t::xdata_t::date), - make_setter(&post_t::xdata_t::date)) + make_getter(&post_t::xdata_t::date), + make_setter(&post_t::xdata_t::date)) .add_property("datetime", - make_getter(&post_t::xdata_t::datetime), - make_setter(&post_t::xdata_t::datetime)) + make_getter(&post_t::xdata_t::datetime), + make_setter(&post_t::xdata_t::datetime)) .add_property("account", - make_getter(&post_t::xdata_t::account, - return_value_policy<reference_existing_object>()), - make_setter(&post_t::xdata_t::account, - with_custodian_and_ward<1, 2>())) + make_getter(&post_t::xdata_t::account, + return_value_policy<reference_existing_object>()), + make_setter(&post_t::xdata_t::account, + with_custodian_and_ward<1, 2>())) .add_property("sort_values", - make_getter(&post_t::xdata_t::sort_values), - make_setter(&post_t::xdata_t::sort_values)) + make_getter(&post_t::xdata_t::sort_values), + make_setter(&post_t::xdata_t::sort_values)) ; - scope().attr("POST_VIRTUAL") = POST_VIRTUAL; + scope().attr("POST_VIRTUAL") = POST_VIRTUAL; scope().attr("POST_MUST_BALANCE") = POST_MUST_BALANCE; scope().attr("POST_CALCULATED") = POST_CALCULATED; scope().attr("POST_COST_CALCULATED") = POST_COST_CALCULATED; @@ -133,24 +133,24 @@ void export_post() //.def(init<account_t *>()) .add_property("xact", - make_getter(&post_t::xact, - return_internal_reference<>()), - make_setter(&post_t::xact, - with_custodian_and_ward<1, 2>())) + make_getter(&post_t::xact, + return_internal_reference<>()), + make_setter(&post_t::xact, + with_custodian_and_ward<1, 2>())) .add_property("account", - make_getter(&post_t::account, - return_internal_reference<>()), - make_setter(&post_t::account, - with_custodian_and_ward<1, 2>())) + make_getter(&post_t::account, + return_internal_reference<>()), + make_setter(&post_t::account, + with_custodian_and_ward<1, 2>())) .add_property("amount", - make_getter(&post_t::amount), - make_setter(&post_t::amount)) + make_getter(&post_t::amount), + make_setter(&post_t::amount)) .add_property("cost", - make_getter(&post_t::cost), - make_setter(&post_t::cost)) + make_getter(&post_t::cost), + make_setter(&post_t::cost)) .add_property("assigned_amount", - make_getter(&post_t::assigned_amount), - make_setter(&post_t::assigned_amount)) + make_getter(&post_t::assigned_amount), + make_setter(&post_t::assigned_amount)) .def("has_tag", py_has_tag_1s) .def("has_tag", py_has_tag_1m) @@ -171,13 +171,13 @@ void export_post() .def("has_xdata", &post_t::has_xdata) .def("clear_xdata", &post_t::clear_xdata) .def("xdata", py_xdata, - return_internal_reference<>()) + return_internal_reference<>()) .def("add_to_value", &post_t::add_to_value) .def("set_reported_account", &post_t::set_reported_account) .def("reported_account", py_reported_account, - return_internal_reference<>()) + return_internal_reference<>()) ; } diff --git a/src/py_times.cc b/src/py_times.cc index 39b0df7a..c2e0b8f8 100644 --- a/src/py_times.cc +++ b/src/py_times.cc @@ -41,10 +41,10 @@ namespace ledger { using namespace boost::python; -#define MY_PyDateTime_IMPORT \ - PyDateTimeAPI = (PyDateTime_CAPI*) \ - PyCObject_Import(const_cast<char *>("datetime"), \ - const_cast<char *>("datetime_CAPI")) +#define MY_PyDateTime_IMPORT \ + PyDateTimeAPI = (PyDateTime_CAPI*) \ + PyCObject_Import(const_cast<char *>("datetime"), \ + const_cast<char *>("datetime_CAPI")) struct date_to_python { @@ -65,7 +65,7 @@ struct date_from_python } static void construct(PyObject * obj_ptr, - converter::rvalue_from_python_stage1_data * data) + converter::rvalue_from_python_stage1_data * data) { MY_PyDateTime_IMPORT; @@ -113,7 +113,7 @@ struct datetime_from_python } static void construct(PyObject * obj_ptr, - converter::rvalue_from_python_stage1_data * data) + converter::rvalue_from_python_stage1_data * data) { MY_PyDateTime_IMPORT; @@ -139,14 +139,14 @@ struct datetime_from_python datetime_t * moment = new datetime_t(date_t(y, m, d), - datetime_t::time_duration_type(h, min, s, ms)); + datetime_t::time_duration_type(h, min, s, ms)); data->convertible = (void *) moment; } }; typedef register_python_conversion<datetime_t, - datetime_to_python, datetime_from_python> + datetime_to_python, datetime_from_python> datetime_python_conversion; @@ -189,7 +189,7 @@ struct duration_from_python } static void construct(PyObject* obj_ptr, - python::converter::rvalue_from_python_stage1_data * data) + python::converter::rvalue_from_python_stage1_data * data) { PyDateTime_Delta const* pydelta = reinterpret_cast<PyDateTime_Delta*>(obj_ptr); @@ -202,8 +202,8 @@ struct duration_from_python // Create time duration object posix_time::time_duration duration = (posix_time::hours(24) * days + - posix_time::seconds(pydelta->seconds) + - posix_time::microseconds(pydelta->microseconds)); + posix_time::seconds(pydelta->seconds) + + posix_time::microseconds(pydelta->microseconds)); if (is_negative) duration = duration.invert_sign(); @@ -218,7 +218,7 @@ struct duration_from_python }; typedef register_python_conversion<time_duration_t, - duration_to_python, duration_from_python> + duration_to_python, duration_from_python> duration_python_conversion; @@ -240,7 +240,7 @@ void export_times() register_optional_to_python<date_t>(); scope().attr("parse_datetime") = &py_parse_datetime; - scope().attr("parse_date") = &py_parse_date; + scope().attr("parse_date") = &py_parse_date; scope().attr("times_initialize") = ×_initialize; scope().attr("times_shutdown") = ×_shutdown; diff --git a/src/py_utils.cc b/src/py_utils.cc index 952416cc..c513def4 100644 --- a/src/py_utils.cc +++ b/src/py_utils.cc @@ -59,7 +59,7 @@ struct bool_from_python } static void construct(PyObject* obj_ptr, - converter::rvalue_from_python_stage1_data* data) + converter::rvalue_from_python_stage1_data* data) { void * storage = ((converter::rvalue_from_python_storage<bool>*) data)->storage.bytes; @@ -89,19 +89,19 @@ struct string_from_python static void* convertible(PyObject* obj_ptr) { if (!PyUnicode_Check(obj_ptr) && - !PyString_Check(obj_ptr)) return 0; + !PyString_Check(obj_ptr)) return 0; return obj_ptr; } static void construct(PyObject* obj_ptr, - converter::rvalue_from_python_stage1_data* data) + converter::rvalue_from_python_stage1_data* data) { if (PyString_Check(obj_ptr)) { const char* value = PyString_AsString(obj_ptr); if (value == 0) throw_error_already_set(); void* storage = - reinterpret_cast<converter::rvalue_from_python_storage<string> *> - (data)->storage.bytes; + reinterpret_cast<converter::rvalue_from_python_storage<string> *> + (data)->storage.bytes; new (storage) string(value); data->convertible = storage; } else { @@ -112,18 +112,18 @@ struct string_from_python string str; if (sizeof(Py_UNICODE) == 2) // UTF-16 - utf8::unchecked::utf16to8(value, value + size, std::back_inserter(str)); + utf8::unchecked::utf16to8(value, value + size, std::back_inserter(str)); else if (sizeof(Py_UNICODE) == 4) // UTF-32 - utf8::unchecked::utf32to8(value, value + size, std::back_inserter(str)); + utf8::unchecked::utf32to8(value, value + size, std::back_inserter(str)); #if !defined(NO_ASSERTS) else - assert(! "Py_UNICODE has an unexpected size"); + assert(! "Py_UNICODE has an unexpected size"); #endif if (value == 0) throw_error_already_set(); void* storage = - reinterpret_cast<converter::rvalue_from_python_storage<string> *> - (data)->storage.bytes; + reinterpret_cast<converter::rvalue_from_python_storage<string> *> + (data)->storage.bytes; new (storage) string(str); data->convertible = storage; } @@ -151,7 +151,7 @@ struct istream_from_python } static void construct(PyObject* obj_ptr, - converter::rvalue_from_python_stage1_data* data) + converter::rvalue_from_python_stage1_data* data) { void* storage = reinterpret_cast<converter::rvalue_from_python_storage<pyifstream> *> @@ -162,7 +162,7 @@ struct istream_from_python }; typedef register_python_conversion<std::istream, - istream_to_python, istream_from_python> + istream_to_python, istream_from_python> istream_python_conversion; @@ -183,7 +183,7 @@ struct ostream_from_python } static void construct(PyObject* obj_ptr, - converter::rvalue_from_python_stage1_data* data) + converter::rvalue_from_python_stage1_data* data) { void* storage = reinterpret_cast<converter::rvalue_from_python_storage<pyofstream> *> @@ -194,7 +194,7 @@ struct ostream_from_python }; typedef register_python_conversion<std::ostream, - ostream_to_python, ostream_from_python> + ostream_to_python, ostream_from_python> ostream_python_conversion; @@ -205,8 +205,8 @@ void export_utils() .def(init<uint_least8_t>()) .add_property("flags", - &supports_flags<uint_least8_t>::flags, - &supports_flags<uint_least8_t>::set_flags) + &supports_flags<uint_least8_t>::flags, + &supports_flags<uint_least8_t>::set_flags) .def("has_flags", &supports_flags<uint_least8_t>::has_flags) .def("clear_flags", &supports_flags<uint_least8_t>::clear_flags) .def("add_flags", &supports_flags<uint_least8_t>::add_flags) @@ -218,8 +218,8 @@ void export_utils() .def(init<uint_least16_t>()) .add_property("flags", - &supports_flags<uint_least16_t>::flags, - &supports_flags<uint_least16_t>::set_flags) + &supports_flags<uint_least16_t>::flags, + &supports_flags<uint_least16_t>::set_flags) .def("has_flags", &supports_flags<uint_least16_t>::has_flags) .def("clear_flags", &supports_flags<uint_least16_t>::clear_flags) .def("add_flags", &supports_flags<uint_least16_t>::add_flags) @@ -237,10 +237,10 @@ void export_utils() #endif class_< delegates_flags<uint_least16_t>, - boost::noncopyable > ("DelegatesFlags16", no_init) + boost::noncopyable > ("DelegatesFlags16", no_init) .add_property("flags", - &delegates_flags<uint_least16_t>::flags, - &delegates_flags<uint_least16_t>::set_flags) + &delegates_flags<uint_least16_t>::flags, + &delegates_flags<uint_least16_t>::set_flags) .def("has_flags", &delegates_flags<uint_least16_t>::has_flags) .def("clear_flags", &delegates_flags<uint_least16_t>::clear_flags) .def("add_flags", &delegates_flags<uint_least16_t>::add_flags) diff --git a/src/py_value.cc b/src/py_value.cc index dabda427..f8f36453 100644 --- a/src/py_value.cc +++ b/src/py_value.cc @@ -42,7 +42,7 @@ using namespace boost::python; BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(value_overloads, value, 0, 2) BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(exchange_commodities_overloads, - exchange_commodities, 1, 2) + exchange_commodities, 1, 2) BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_string_overloads, set_string, 0, 2) namespace { @@ -51,12 +51,12 @@ namespace { return value.value(CURRENT_TIME()); } boost::optional<value_t> py_value_1(const value_t& value, - commodity_t& in_terms_of) { + commodity_t& in_terms_of) { return value.value(CURRENT_TIME(), in_terms_of); } boost::optional<value_t> py_value_2(const value_t& value, - commodity_t& in_terms_of, - datetime_t& moment) { + commodity_t& in_terms_of, + datetime_t& moment) { return value.value(moment, in_terms_of); } @@ -110,9 +110,9 @@ namespace { } // unnamed namespace -#define EXC_TRANSLATOR(type) \ - void exc_translate_ ## type(const type& err) { \ - PyErr_SetString(PyExc_ArithmeticError, err.what()); \ +#define EXC_TRANSLATOR(type) \ + void exc_translate_ ## type(const type& err) { \ + PyErr_SetString(PyExc_ArithmeticError, err.what()); \ } EXC_TRANSLATOR(value_error) @@ -120,16 +120,16 @@ EXC_TRANSLATOR(value_error) void export_value() { enum_< value_t::type_t >("ValueType") - .value("Void", value_t::VOID) - .value("Boolean", value_t::BOOLEAN) - .value("DateTime", value_t::DATETIME) - .value("Date", value_t::DATE) - .value("Integer", value_t::INTEGER) - .value("Amount", value_t::AMOUNT) - .value("Balance", value_t::BALANCE) - .value("String", value_t::STRING) - .value("Sequence", value_t::SEQUENCE) - .value("Scope", value_t::SCOPE) + .value("Void", value_t::VOID) + .value("Boolean", value_t::BOOLEAN) + .value("DateTime", value_t::DATETIME) + .value("Date", value_t::DATE) + .value("Integer", value_t::INTEGER) + .value("Amount", value_t::AMOUNT) + .value("Balance", value_t::BALANCE) + .value("String", value_t::STRING) + .value("Sequence", value_t::SEQUENCE) + .value("Scope", value_t::SCOPE) ; class_< value_t > ("Value") @@ -214,9 +214,9 @@ void export_value() .def(self -= other<amount_t>()) .def(self -= other<balance_t>()) - .def(self - self) - .def(self - long()) - .def(long() - self) + .def(self - self) + .def(self - long()) + .def(long() - self) .def(self - other<amount_t>()) .def(other<amount_t>() - self) .def(self - other<balance_t>()) @@ -225,8 +225,8 @@ void export_value() .def(self *= long()) .def(self *= other<amount_t>()) - .def(self * self) - .def(self * long()) + .def(self * self) + .def(self * long()) .def(long() * self) .def(self * other<amount_t>()) .def(other<amount_t>() * self) @@ -235,9 +235,9 @@ void export_value() .def(self /= long()) .def(self /= other<amount_t>()) - .def(self / self) - .def(self / long()) - .def(long() / self) + .def(self / self) + .def(self / long()) + .def(long() / self) .def(self / other<amount_t>()) .def(other<amount_t>() / self) @@ -269,7 +269,7 @@ void export_value() .def("value", &value_t::value, value_overloads()) .def("price", &value_t::price) .def("exchange_commodities", &value_t::exchange_commodities, - exchange_commodities_overloads()) + exchange_commodities_overloads()) .def("__nonzero__", &value_t::is_nonzero) .def("is_nonzero", &value_t::is_nonzero) @@ -333,8 +333,8 @@ void export_value() .def("annotate", &value_t::annotate) .def("has_annotation", &value_t::has_annotation) .add_property("annotation", - make_function(py_value_annotation, - return_internal_reference<>())) + make_function(py_value_annotation, + return_internal_reference<>())) .def("strip_annotations", py_strip_annotations_0) .def("strip_annotations", py_strip_annotations_1) @@ -362,7 +362,7 @@ void export_value() scope().attr("NULL_VALUE") = NULL_VALUE; scope().attr("string_value") = &string_value; - scope().attr("mask_value") = &mask_value; + scope().attr("mask_value") = &mask_value; scope().attr("value_context") = &value_context; register_optional_to_python<value_t>(); diff --git a/src/py_xact.cc b/src/py_xact.cc index 6553a67f..5ab0d90d 100644 --- a/src/py_xact.cc +++ b/src/py_xact.cc @@ -84,14 +84,14 @@ void export_xact() { class_< xact_base_t, bases<item_t> > ("TransactionBase") .add_property("journal", - make_getter(&xact_base_t::journal, - return_internal_reference<>()), - make_setter(&xact_base_t::journal, - with_custodian_and_ward<1, 2>())) + make_getter(&xact_base_t::journal, + return_internal_reference<>()), + make_setter(&xact_base_t::journal, + with_custodian_and_ward<1, 2>())) .def("__len__", posts_len) .def("__getitem__", posts_getitem, - return_internal_reference<>()) + return_internal_reference<>()) .def("add_post", &xact_base_t::add_post, with_custodian_and_ward<1, 2>()) .def("remove_post", &xact_base_t::add_post) @@ -99,20 +99,20 @@ void export_xact() .def("finalize", &xact_base_t::finalize) .def("__iter__", python::range<return_internal_reference<> > - (&xact_t::posts_begin, &xact_t::posts_end)) + (&xact_t::posts_begin, &xact_t::posts_end)) .def("posts", python::range<return_internal_reference<> > - (&xact_t::posts_begin, &xact_t::posts_end)) + (&xact_t::posts_begin, &xact_t::posts_end)) .def("valid", &xact_base_t::valid) ; class_< xact_t, bases<xact_base_t> > ("Transaction") .add_property("code", - make_getter(&xact_t::code), - make_setter(&xact_t::code)) + make_getter(&xact_t::code), + make_setter(&xact_t::code)) .add_property("payee", - make_getter(&xact_t::payee), - make_setter(&xact_t::payee)) + make_getter(&xact_t::payee), + make_setter(&xact_t::payee)) .def("add_post", &xact_t::add_post, with_custodian_and_ward<1, 2>()) @@ -132,8 +132,8 @@ void export_xact() .def(init<predicate_t>()) .add_property("predicate", - make_getter(&auto_xact_t::predicate), - make_setter(&auto_xact_t::predicate)) + make_getter(&auto_xact_t::predicate), + make_setter(&auto_xact_t::predicate)) .def("extend_xact", &auto_xact_t::extend_xact) ; @@ -142,11 +142,11 @@ void export_xact() .def(init<string>()) .add_property("period", - make_getter(&period_xact_t::period), - make_setter(&period_xact_t::period)) + make_getter(&period_xact_t::period), + make_setter(&period_xact_t::period)) .add_property("period_string", - make_getter(&period_xact_t::period_string), - make_setter(&period_xact_t::period_string)) + make_getter(&period_xact_t::period_string), + make_setter(&period_xact_t::period_string)) ; } diff --git a/src/pyfstream.h b/src/pyfstream.h index 02e4d240..37978ff4 100644 --- a/src/pyfstream.h +++ b/src/pyfstream.h @@ -59,7 +59,7 @@ protected: z[0] = static_cast<char>(c); z[1] = '\0'; if (PyFile_WriteString(z, reinterpret_cast<PyObject *>(fo)) < 0) { - return EOF; + return EOF; } } return c; @@ -124,8 +124,8 @@ public: TRACE_CTOR(pyinbuf, "PyFileObject *"); setg (buffer+pbSize, // beginning of putback area - buffer+pbSize, // read position - buffer+pbSize); // end position + buffer+pbSize, // read position + buffer+pbSize); // end position } ~pyinbuf() throw() { TRACE_DTOR(pyinbuf); @@ -157,7 +157,7 @@ protected: * the putback area */ memmove (buffer+(pbSize-numPutback), gptr()-numPutback, - numPutback); + numPutback); // read at most bufSize new characters PyObject *line = PyFile_GetLine(reinterpret_cast<PyObject *>(fo), bufSize); @@ -174,8 +174,8 @@ protected: // reset buffer pointers setg (buffer+(pbSize-numPutback), // beginning of putback area - buffer+pbSize, // read position - buffer+pbSize+num); // end of buffer + buffer+pbSize, // read position + buffer+pbSize+num); // end of buffer // return next character return traits_type::to_int_type(*gptr()); diff --git a/src/pyinterp.cc b/src/pyinterp.cc index 1330fc5c..76fc0561 100644 --- a/src/pyinterp.cc +++ b/src/pyinterp.cc @@ -80,10 +80,10 @@ struct python_run object result; python_run(python_interpreter_t * intepreter, - const string& str, int input_mode) + const string& str, int input_mode) : result(handle<>(borrowed(PyRun_String(str.c_str(), input_mode, - intepreter->main_nspace.ptr(), - intepreter->main_nspace.ptr())))) {} + intepreter->main_nspace.ptr(), + intepreter->main_nspace.ptr())))) {} operator object() { return result; } @@ -104,12 +104,12 @@ void python_interpreter_t::initialize() object main_module = python::import("__main__"); if (! main_module) throw_(std::runtime_error, - _("Python failed to initialize (couldn't find __main__)")); + _("Python failed to initialize (couldn't find __main__)")); main_nspace = extract<dict>(main_module.attr("__dict__")); if (! main_nspace) throw_(std::runtime_error, - _("Python failed to initialize (couldn't find __dict__)")); + _("Python failed to initialize (couldn't find __dict__)")); python::detail::init_module("ledger", &initialize_for_python); @@ -142,17 +142,17 @@ void python_interpreter_t::hack_system_paths() if (exists(pathname / "ledger" / "__init__.py")) { if (python::object module_ledger = python::import("ledger")) { - DEBUG("python.interp", - "Setting ledger.__path__ = " << (pathname / "ledger")); + DEBUG("python.interp", + "Setting ledger.__path__ = " << (pathname / "ledger")); - python::object ledger_dict = module_ledger.attr("__dict__"); - python::list temp_list; - temp_list.append((pathname / "ledger").string()); + python::object ledger_dict = module_ledger.attr("__dict__"); + python::list temp_list; + temp_list.append((pathname / "ledger").string()); - ledger_dict["__path__"] = temp_list; + ledger_dict["__path__"] = temp_list; } else { - throw_(std::runtime_error, - _("Python failed to initialize (couldn't find ledger)")); + throw_(std::runtime_error, + _("Python failed to initialize (couldn't find ledger)")); } #if defined(DEBUG_ON) path_initialized = true; @@ -163,7 +163,7 @@ void python_interpreter_t::hack_system_paths() #if defined(DEBUG_ON) if (! path_initialized) DEBUG("python.init", - "Ledger failed to find 'ledger/__init__.py' on the PYTHONPATH"); + "Ledger failed to find 'ledger/__init__.py' on the PYTHONPATH"); #endif } @@ -176,7 +176,7 @@ object python_interpreter_t::import_into_main(const string& str) object mod = python::import(str.c_str()); if (! mod) throw_(std::runtime_error, - _("Failed to import Python module %1") << str); + _("Failed to import Python module %1") << str); // Import all top-level entries directly into the main namespace main_nspace.update(mod.attr("__dict__")); @@ -217,7 +217,7 @@ object python_interpreter_t::import_option(const string& str) object python_interpreter_t::eval(std::istream& in, py_eval_mode_t mode) { - bool first = true; + bool first = true; string buffer; buffer.reserve(4096); @@ -328,12 +328,12 @@ value_t python_interpreter_t::server_command(call_scope_t& args) server_module = python::import("ledger.server"); if (! server_module) throw_(std::runtime_error, - _("Could not import ledger.server; please check your PYTHONPATH")); + _("Could not import ledger.server; please check your PYTHONPATH")); } catch (const error_already_set&) { PyErr_Print(); throw_(std::runtime_error, - _("Could not import ledger.server; please check your PYTHONPATH")); + _("Could not import ledger.server; please check your PYTHONPATH")); } if (python::object main_function = server_module.attr("main")) { @@ -344,12 +344,12 @@ value_t python_interpreter_t::server_command(call_scope_t& args) catch (const error_already_set&) { PyErr_Print(); throw_(std::runtime_error, - _("Error while invoking ledger.server's main() function")); + _("Error while invoking ledger.server's main() function")); } return true; } else { throw_(std::runtime_error, - _("The ledger.server module is missing its main() function!")); + _("The ledger.server module is missing its main() function!")); } return false; @@ -367,7 +367,7 @@ python_interpreter_t::lookup_option(const char * p) } expr_t::ptr_op_t python_interpreter_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { // Give our superclass first dibs on symbol definitions if (expr_t::ptr_op_t op = session_t::lookup(kind, name)) @@ -382,7 +382,7 @@ expr_t::ptr_op_t python_interpreter_t::lookup(const symbol_t::kind_t kind, DEBUG("python.interp", "Python lookup: " << name); if (python::object obj = main_nspace.get(name.c_str())) - return WRAP_FUNCTOR(functor_t(obj, name)); + return WRAP_FUNCTOR(functor_t(obj, name)); } break; @@ -396,12 +396,12 @@ expr_t::ptr_op_t python_interpreter_t::lookup(const symbol_t::kind_t kind, switch (*p) { case 'p': if (is_eq(p, "python")) - return MAKE_FUNCTOR(python_interpreter_t::python_command); + return MAKE_FUNCTOR(python_interpreter_t::python_command); break; case 's': if (is_eq(p, "server")) - return MAKE_FUNCTOR(python_interpreter_t::server_command); + return MAKE_FUNCTOR(python_interpreter_t::server_command); break; } } @@ -419,21 +419,21 @@ namespace { if (value.is_scope()) { const scope_t * scope = value.as_scope(); if (const post_t * post = dynamic_cast<const post_t *>(scope)) - lst.append(ptr(post)); + lst.append(ptr(post)); else if (const xact_t * xact = dynamic_cast<const xact_t *>(scope)) - lst.append(ptr(xact)); + lst.append(ptr(xact)); else if (const account_t * account = - dynamic_cast<const account_t *>(scope)) - lst.append(ptr(account)); + dynamic_cast<const account_t *>(scope)) + lst.append(ptr(account)); else if (const period_xact_t * period_xact = - dynamic_cast<const period_xact_t *>(scope)) - lst.append(ptr(period_xact)); + dynamic_cast<const period_xact_t *>(scope)) + lst.append(ptr(period_xact)); else if (const auto_xact_t * auto_xact = - dynamic_cast<const auto_xact_t *>(scope)) - lst.append(ptr(auto_xact)); + dynamic_cast<const auto_xact_t *>(scope)) + lst.append(ptr(auto_xact)); else - throw_(std::logic_error, - _("Cannot downcast scoped object to specific type")); + throw_(std::logic_error, + _("Cannot downcast scoped object to specific type")); } else { lst.append(value); } @@ -449,7 +449,7 @@ value_t python_interpreter_t::functor_t::operator()(call_scope_t& args) extract<value_t> val(func); std::signal(SIGINT, sigint_handler); if (val.check()) - return val(); + return val(); return NULL_VALUE; } else if (args.size() > 0) { @@ -457,31 +457,31 @@ value_t python_interpreter_t::functor_t::operator()(call_scope_t& args) // jww (2009-11-05): What about a single argument which is a sequence, // rather than a sequence of arguments? if (args.value().is_sequence()) - foreach (const value_t& value, args.value().as_sequence()) - append_value(arglist, value); + foreach (const value_t& value, args.value().as_sequence()) + append_value(arglist, value); else - append_value(arglist, args.value()); + append_value(arglist, args.value()); if (PyObject * val = - PyObject_CallObject(func.ptr(), python::tuple(arglist).ptr())) { - extract<value_t> xval(val); - value_t result; - if (xval.check()) { - result = xval(); - Py_DECREF(val); - } else { - Py_DECREF(val); - throw_(calc_error, - _("Could not evaluate Python variable '%1'") << name); - } - std::signal(SIGINT, sigint_handler); - return result; + PyObject_CallObject(func.ptr(), python::tuple(arglist).ptr())) { + extract<value_t> xval(val); + value_t result; + if (xval.check()) { + result = xval(); + Py_DECREF(val); + } else { + Py_DECREF(val); + throw_(calc_error, + _("Could not evaluate Python variable '%1'") << name); + } + std::signal(SIGINT, sigint_handler); + return result; } else if (PyErr_Occurred()) { - PyErr_Print(); - throw_(calc_error, _("Failed call to Python function '%1'") << name); + PyErr_Print(); + throw_(calc_error, _("Failed call to Python function '%1'") << name); } else { - assert(false); + assert(false); } } else { diff --git a/src/pyinterp.h b/src/pyinterp.h index e3a091ad..3d747d5c 100644 --- a/src/pyinterp.h +++ b/src/pyinterp.h @@ -69,11 +69,11 @@ public: }; python::object eval(std::istream& in, - py_eval_mode_t mode = PY_EVAL_EXPR); + py_eval_mode_t mode = PY_EVAL_EXPR); python::object eval(const string& str, - py_eval_mode_t mode = PY_EVAL_EXPR); + py_eval_mode_t mode = PY_EVAL_EXPR); python::object eval(const char * c_str, - py_eval_mode_t mode = PY_EVAL_EXPR) { + py_eval_mode_t mode = PY_EVAL_EXPR) { string str(c_str); return eval(str, mode); } @@ -107,7 +107,7 @@ public: option_t<python_interpreter_t> * lookup_option(const char * p); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); OPTION_(python_interpreter_t, import_, DO_(scope) { interactive_t args(scope, "ss"); diff --git a/src/pyutils.h b/src/pyutils.h index e0f77003..efb1b858 100644 --- a/src/pyutils.h +++ b/src/pyutils.h @@ -59,8 +59,8 @@ struct register_optional_to_python : public boost::noncopyable static PyObject * convert(const boost::optional<T>& value) { return boost::python::incref - (value ? boost::python::to_python_value<T>()(*value) : - boost::python::detail::none()); + (value ? boost::python::to_python_value<T>()(*value) : + boost::python::detail::none()); } }; @@ -71,30 +71,30 @@ struct register_optional_to_python : public boost::noncopyable using namespace boost::python::converter; if (source == Py_None) - return source; + return source; const registration& converters(registered<T>::converters); if (implicit_rvalue_convertible_from_python(source, converters)) { - rvalue_from_python_stage1_data data = - rvalue_from_python_stage1(source, converters); - return rvalue_from_python_stage2(source, data, converters); + rvalue_from_python_stage1_data data = + rvalue_from_python_stage1(source, converters); + return rvalue_from_python_stage2(source, data, converters); } return NULL; } static void construct(PyObject * source, - boost::python::converter::rvalue_from_python_stage1_data * data) + boost::python::converter::rvalue_from_python_stage1_data * data) { using namespace boost::python::converter; void * const storage = - reinterpret_cast<rvalue_from_python_storage<T> *>(data)->storage.bytes; + reinterpret_cast<rvalue_from_python_storage<T> *>(data)->storage.bytes; - if (data->convertible == source) // == None - new (storage) boost::optional<T>(); // A Boost uninitialized value + if (data->convertible == source) // == None + new (storage) boost::optional<T>(); // A Boost uninitialized value else - new (storage) boost::optional<T>(*reinterpret_cast<T *>(data->convertible)); + new (storage) boost::optional<T>(*reinterpret_cast<T *>(data->convertible)); data->convertible = storage; } diff --git a/src/query.cc b/src/query.cc index 363c6f73..404c101f 100644 --- a/src/query.cc +++ b/src/query.cc @@ -58,17 +58,17 @@ query_t::lexer_t::token_t query_t::lexer_t::next_token() case '"': case '/': { string pat; - char closing = *arg_i; + char closing = *arg_i; bool found_closing = false; for (++arg_i; arg_i != arg_end; ++arg_i) { if (*arg_i == '\\') { - if (++arg_i == arg_end) - throw_(parse_error, _("Unexpected '\\' at end of pattern")); + if (++arg_i == arg_end) + throw_(parse_error, _("Unexpected '\\' at end of pattern")); } else if (*arg_i == closing) { - ++arg_i; - found_closing = true; - break; + ++arg_i; + found_closing = true; + break; } pat.push_back(*arg_i); } @@ -125,11 +125,11 @@ query_t::lexer_t::token_t query_t::lexer_t::next_token() case '\t': case '\n': case '\r': - if (! consume_whitespace) - goto test_ident; - else - ident.push_back(*arg_i); - break; + if (! consume_whitespace) + goto test_ident; + else + ident.push_back(*arg_i); + break; case '(': case ')': case '&': @@ -139,12 +139,12 @@ query_t::lexer_t::token_t query_t::lexer_t::next_token() case '#': case '%': case '=': - if (! consume_next) - goto test_ident; + if (! consume_next) + goto test_ident; // fall through... default: - ident.push_back(*arg_i); - break; + ident.push_back(*arg_i); + break; } } consume_whitespace = false; @@ -251,7 +251,7 @@ query_t::parser_t::parse_query_term(query_t::lexer_t::token_t::kind_t tok_contex node = parse_query_term(tok.kind); if (! node) throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol()); + _("%1 operator not followed by argument") << tok.symbol()); break; case lexer_t::token_t::TERM: @@ -264,30 +264,30 @@ query_t::parser_t::parse_query_term(query_t::lexer_t::token_t::kind_t tok_contex date_interval_t interval(*tok.value); if (interval.start) { - node = new expr_t::op_t(expr_t::op_t::O_GTE); - node->set_left(ident); + node = new expr_t::op_t(expr_t::op_t::O_GTE); + node->set_left(ident); - expr_t::ptr_op_t arg1 = new expr_t::op_t(expr_t::op_t::VALUE); - arg1->set_value(*interval.start); - node->set_right(arg1); + expr_t::ptr_op_t arg1 = new expr_t::op_t(expr_t::op_t::VALUE); + arg1->set_value(*interval.start); + node->set_right(arg1); } if (interval.finish) { - expr_t::ptr_op_t lt = new expr_t::op_t(expr_t::op_t::O_LT); - lt->set_left(ident); - - expr_t::ptr_op_t arg1 = new expr_t::op_t(expr_t::op_t::VALUE); - arg1->set_value(*interval.finish); - lt->set_right(arg1); - - if (node) { - expr_t::ptr_op_t prev(node); - node = new expr_t::op_t(expr_t::op_t::O_AND); - node->set_left(prev); - node->set_right(lt); - } else { - node = lt; - } + expr_t::ptr_op_t lt = new expr_t::op_t(expr_t::op_t::O_LT); + lt->set_left(ident); + + expr_t::ptr_op_t arg1 = new expr_t::op_t(expr_t::op_t::VALUE); + arg1->set_value(*interval.finish); + lt->set_right(arg1); + + if (node) { + expr_t::ptr_op_t prev(node); + node = new expr_t::op_t(expr_t::op_t::O_AND); + node->set_left(prev); + node->set_right(lt); + } else { + node = lt; + } } break; } @@ -308,22 +308,22 @@ query_t::parser_t::parse_query_term(query_t::lexer_t::token_t::kind_t tok_contex tok = lexer.peek_token(); if (tok.kind == lexer_t::token_t::TOK_EQ) { - tok = lexer.next_token(); - tok = lexer.next_token(); - if (tok.kind != lexer_t::token_t::TERM) - throw_(parse_error, - _("Metadata equality operator not followed by term")); - - expr_t::ptr_op_t arg2 = new expr_t::op_t(expr_t::op_t::VALUE); - assert(tok.value); - arg2->set_value(mask_t(*tok.value)); - - node->set_right(expr_t::op_t::new_node - (expr_t::op_t::O_SEQ, - expr_t::op_t::new_node - (expr_t::op_t::O_CONS, arg1, arg2))); + tok = lexer.next_token(); + tok = lexer.next_token(); + if (tok.kind != lexer_t::token_t::TERM) + throw_(parse_error, + _("Metadata equality operator not followed by term")); + + expr_t::ptr_op_t arg2 = new expr_t::op_t(expr_t::op_t::VALUE); + assert(tok.value); + arg2->set_value(mask_t(*tok.value)); + + node->set_right(expr_t::op_t::new_node + (expr_t::op_t::O_SEQ, + expr_t::op_t::new_node + (expr_t::op_t::O_CONS, arg1, arg2))); } else { - node->set_right(arg1); + node->set_right(arg1); } break; } @@ -334,15 +334,15 @@ query_t::parser_t::parse_query_term(query_t::lexer_t::token_t::kind_t tok_contex expr_t::ptr_op_t ident = new expr_t::op_t(expr_t::op_t::IDENT); switch (tok_context) { case lexer_t::token_t::TOK_ACCOUNT: - ident->set_ident("account"); break; + ident->set_ident("account"); break; case lexer_t::token_t::TOK_PAYEE: - ident->set_ident("payee"); break; + ident->set_ident("payee"); break; case lexer_t::token_t::TOK_CODE: - ident->set_ident("code"); break; + ident->set_ident("code"); break; case lexer_t::token_t::TOK_NOTE: - ident->set_ident("note"); break; + ident->set_ident("note"); break; default: - assert(false); break; + assert(false); break; } expr_t::ptr_op_t mask = new expr_t::op_t(expr_t::op_t::VALUE); @@ -382,7 +382,7 @@ query_t::parser_t::parse_unary_expr(lexer_t::token_t::kind_t tok_context) expr_t::ptr_op_t term(parse_query_term(tok_context)); if (! term) throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol()); + _("%1 operator not followed by argument") << tok.symbol()); node = new expr_t::op_t(expr_t::op_t::O_NOT); node->set_left(term); @@ -405,16 +405,16 @@ query_t::parser_t::parse_and_expr(lexer_t::token_t::kind_t tok_context) while (true) { lexer_t::token_t tok = lexer.next_token(); if (tok.kind == lexer_t::token_t::TOK_AND) { - expr_t::ptr_op_t prev(node); - node = new expr_t::op_t(expr_t::op_t::O_AND); - node->set_left(prev); - node->set_right(parse_unary_expr(tok_context)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol()); + expr_t::ptr_op_t prev(node); + node = new expr_t::op_t(expr_t::op_t::O_AND); + node->set_left(prev); + node->set_right(parse_unary_expr(tok_context)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol()); } else { - lexer.push_token(tok); - break; + lexer.push_token(tok); + break; } } return node; @@ -429,16 +429,16 @@ query_t::parser_t::parse_or_expr(lexer_t::token_t::kind_t tok_context) while (true) { lexer_t::token_t tok = lexer.next_token(); if (tok.kind == lexer_t::token_t::TOK_OR) { - expr_t::ptr_op_t prev(node); - node = new expr_t::op_t(expr_t::op_t::O_OR); - node->set_left(prev); - node->set_right(parse_and_expr(tok_context)); - if (! node->right()) - throw_(parse_error, - _("%1 operator not followed by argument") << tok.symbol()); + expr_t::ptr_op_t prev(node); + node = new expr_t::op_t(expr_t::op_t::O_OR); + node->set_left(prev); + node->set_right(parse_and_expr(tok_context)); + if (! node->right()) + throw_(parse_error, + _("%1 operator not followed by argument") << tok.symbol()); } else { - lexer.push_token(tok); - break; + lexer.push_token(tok); + break; } } return node; diff --git a/src/query.h b/src/query.h index 59adfd72..e3821f19 100644 --- a/src/query.h +++ b/src/query.h @@ -68,107 +68,107 @@ public: struct token_t { enum kind_t { - UNKNOWN, + UNKNOWN, - LPAREN, - RPAREN, + LPAREN, + RPAREN, - TOK_NOT, - TOK_AND, - TOK_OR, - TOK_EQ, + TOK_NOT, + TOK_AND, + TOK_OR, + TOK_EQ, - TOK_DATE, - TOK_CODE, - TOK_PAYEE, - TOK_NOTE, - TOK_ACCOUNT, - TOK_META, - TOK_EXPR, + TOK_DATE, + TOK_CODE, + TOK_PAYEE, + TOK_NOTE, + TOK_ACCOUNT, + TOK_META, + TOK_EXPR, - TERM, + TERM, - END_REACHED + END_REACHED } kind; optional<string> value; explicit token_t(kind_t _kind = UNKNOWN, - const optional<string>& _value = none) - : kind(_kind), value(_value) { - TRACE_CTOR(query_t::lexer_t::token_t, ""); + const optional<string>& _value = none) + : kind(_kind), value(_value) { + TRACE_CTOR(query_t::lexer_t::token_t, ""); } token_t(const token_t& tok) - : kind(tok.kind), value(tok.value) { - TRACE_CTOR(query_t::lexer_t::token_t, "copy"); + : kind(tok.kind), value(tok.value) { + TRACE_CTOR(query_t::lexer_t::token_t, "copy"); } ~token_t() throw() { - TRACE_DTOR(query_t::lexer_t::token_t); + TRACE_DTOR(query_t::lexer_t::token_t); } token_t& operator=(const token_t& tok) { - if (this != &tok) { - kind = tok.kind; - value = tok.value; - } - return *this; + if (this != &tok) { + kind = tok.kind; + value = tok.value; + } + return *this; } operator bool() const { - return kind != END_REACHED; + return kind != END_REACHED; } string to_string() const { - switch (kind) { - case UNKNOWN: return "UNKNOWN"; - case LPAREN: return "LPAREN"; - case RPAREN: return "RPAREN"; - case TOK_NOT: return "TOK_NOT"; - case TOK_AND: return "TOK_AND"; - case TOK_OR: return "TOK_OR"; - case TOK_EQ: return "TOK_EQ"; - case TOK_DATE: return "TOK_DATE"; - case TOK_CODE: return "TOK_CODE"; - case TOK_PAYEE: return "TOK_PAYEE"; - case TOK_NOTE: return "TOK_NOTE"; - case TOK_ACCOUNT: return "TOK_ACCOUNT"; - case TOK_META: return "TOK_META"; - case TOK_EXPR: return "TOK_EXPR"; - case TERM: return string("TERM(") + *value + ")"; - case END_REACHED: return "END_REACHED"; - } - assert(false); - return empty_string; + switch (kind) { + case UNKNOWN: return "UNKNOWN"; + case LPAREN: return "LPAREN"; + case RPAREN: return "RPAREN"; + case TOK_NOT: return "TOK_NOT"; + case TOK_AND: return "TOK_AND"; + case TOK_OR: return "TOK_OR"; + case TOK_EQ: return "TOK_EQ"; + case TOK_DATE: return "TOK_DATE"; + case TOK_CODE: return "TOK_CODE"; + case TOK_PAYEE: return "TOK_PAYEE"; + case TOK_NOTE: return "TOK_NOTE"; + case TOK_ACCOUNT: return "TOK_ACCOUNT"; + case TOK_META: return "TOK_META"; + case TOK_EXPR: return "TOK_EXPR"; + case TERM: return string("TERM(") + *value + ")"; + case END_REACHED: return "END_REACHED"; + } + assert(false); + return empty_string; } string symbol() const { - switch (kind) { - case LPAREN: return "("; - case RPAREN: return ")"; - case TOK_NOT: return "not"; - case TOK_AND: return "and"; - case TOK_OR: return "or"; - case TOK_EQ: return "="; - case TOK_DATE: return "date"; - case TOK_CODE: return "code"; - case TOK_PAYEE: return "payee"; - case TOK_NOTE: return "note"; - case TOK_ACCOUNT: return "account"; - case TOK_META: return "meta"; - case TOK_EXPR: return "expr"; - - case END_REACHED: return "<EOF>"; - - case TERM: - assert(false); - return "<TERM>"; - - case UNKNOWN: - default: - assert(false); - return "<UNKNOWN>"; - } + switch (kind) { + case LPAREN: return "("; + case RPAREN: return ")"; + case TOK_NOT: return "not"; + case TOK_AND: return "and"; + case TOK_OR: return "or"; + case TOK_EQ: return "="; + case TOK_DATE: return "date"; + case TOK_CODE: return "code"; + case TOK_PAYEE: return "payee"; + case TOK_NOTE: return "note"; + case TOK_ACCOUNT: return "account"; + case TOK_META: return "meta"; + case TOK_EXPR: return "expr"; + + case END_REACHED: return "<EOF>"; + + case TERM: + assert(false); + return "<TERM>"; + + case UNKNOWN: + default: + assert(false); + return "<UNKNOWN>"; + } } void unexpected(); @@ -178,11 +178,11 @@ public: token_t token_cache; lexer_t(value_t::sequence_t::const_iterator _begin, - value_t::sequence_t::const_iterator _end, - bool _multiple_args = true) + value_t::sequence_t::const_iterator _end, + bool _multiple_args = true) : begin(_begin), end(_end), - consume_whitespace(false), consume_next_arg(false), - multiple_args(_multiple_args) + consume_whitespace(false), consume_next_arg(false), + multiple_args(_multiple_args) { TRACE_CTOR(query_t::lexer_t, ""); assert(begin != end); @@ -191,11 +191,11 @@ public: } lexer_t(const lexer_t& lexer) : begin(lexer.begin), end(lexer.end), - arg_i(lexer.arg_i), arg_end(lexer.arg_end), - consume_whitespace(lexer.consume_whitespace), - consume_next_arg(lexer.consume_next_arg), - multiple_args(lexer.multiple_args), - token_cache(lexer.token_cache) + arg_i(lexer.arg_i), arg_end(lexer.arg_end), + consume_whitespace(lexer.consume_whitespace), + consume_next_arg(lexer.consume_next_arg), + multiple_args(lexer.multiple_args), + token_cache(lexer.token_cache) { TRACE_CTOR(query_t::lexer_t, "copy"); } @@ -210,7 +210,7 @@ public: } token_t peek_token() { if (token_cache.kind == token_t::UNKNOWN) - token_cache = next_token(); + token_cache = next_token(); return token_cache; } }; @@ -264,8 +264,8 @@ public: TRACE_CTOR(query_t, "copy"); } query_t(const string& arg, - const keep_details_t& _what_to_keep = keep_details_t(), - bool multiple_args = true) + const keep_details_t& _what_to_keep = keep_details_t(), + bool multiple_args = true) : predicate_t(_what_to_keep) { TRACE_CTOR(query_t, "string, keep_details_t"); if (! arg.empty()) { @@ -274,8 +274,8 @@ public: } } query_t(const value_t& args, - const keep_details_t& _what_to_keep = keep_details_t(), - bool multiple_args = true) + const keep_details_t& _what_to_keep = keep_details_t(), + bool multiple_args = true) : predicate_t(_what_to_keep) { TRACE_CTOR(query_t, "value_t, keep_details_t"); if (! args.empty()) @@ -288,12 +288,12 @@ public: void parse_args(const value_t& args, bool multiple_args = true) { if (! parser) parser = parser_t(args, multiple_args); - ptr = parser->parse(); // expr_t::ptr + ptr = parser->parse(); // expr_t::ptr } void parse_again() { assert(parser); - ptr = parser->parse(); // expr_t::ptr + ptr = parser->parse(); // expr_t::ptr } bool tokens_remaining() { diff --git a/src/quotes.cc b/src/quotes.cc index 4e3ec33e..90c1f3eb 100644 --- a/src/quotes.cc +++ b/src/quotes.cc @@ -40,13 +40,13 @@ namespace ledger { optional<price_point_t> commodity_quote_from_script(commodity_t& commodity, - const optional<commodity_t&>& exchange_commodity) + const optional<commodity_t&>& exchange_commodity) { DEBUG("commodity.download", "downloading quote for symbol " << commodity.symbol()); #if defined(DEBUG_ON) if (exchange_commodity) DEBUG("commodity.download", - " in terms of commodity " << exchange_commodity->symbol()); + " in terms of commodity " << exchange_commodity->symbol()); #endif char buf[256]; @@ -76,29 +76,29 @@ commodity_quote_from_script(commodity_t& commodity, DEBUG("commodity.download", "downloaded quote: " << buf); if (optional<std::pair<commodity_t *, price_point_t> > point = - commodity_pool_t::current_pool->parse_price_directive(buf)) { + commodity_pool_t::current_pool->parse_price_directive(buf)) { if (commodity_pool_t::current_pool->price_db) { #if defined(__GNUG__) && __GNUG__ < 3 - ofstream database(*commodity_pool_t::current_pool->price_db, - ios::out | ios::app); + ofstream database(*commodity_pool_t::current_pool->price_db, + ios::out | ios::app); #else - ofstream database(*commodity_pool_t::current_pool->price_db, - std::ios_base::out | std::ios_base::app); + ofstream database(*commodity_pool_t::current_pool->price_db, + std::ios_base::out | std::ios_base::app); #endif - database << "P " - << format_datetime(point->second.when, FMT_WRITTEN) - << " " << commodity.symbol() - << " " << point->second.price - << std::endl; + database << "P " + << format_datetime(point->second.when, FMT_WRITTEN) + << " " << commodity.symbol() + << " " << point->second.price + << std::endl; } return point->second; } } else { DEBUG("commodity.download", - "Failed to download price for '" << commodity.symbol() << - "' (command: \"getquote " << commodity.symbol() << - " " << (exchange_commodity ? - exchange_commodity->symbol() : "''") << "\")"); + "Failed to download price for '" << commodity.symbol() << + "' (command: \"getquote " << commodity.symbol() << + " " << (exchange_commodity ? + exchange_commodity->symbol() : "''") << "\")"); // Don't try to download this commodity again. commodity.add_flags(COMMODITY_NOMARKET); diff --git a/src/quotes.h b/src/quotes.h index e981fdad..376d8918 100644 --- a/src/quotes.h +++ b/src/quotes.h @@ -46,7 +46,7 @@ namespace ledger { optional<price_point_t> commodity_quote_from_script(commodity_t& commodity, - const optional<commodity_t&>& exchange_commodity); + const optional<commodity_t&>& exchange_commodity); } // namespace ledger diff --git a/src/report.cc b/src/report.cc index 1e1827f9..c5cdb843 100644 --- a/src/report.cc +++ b/src/report.cc @@ -76,7 +76,7 @@ void report_t::normalize_options(const string& verb) } item_t::use_effective_date = (HANDLED(effective) && - ! HANDLED(actual_dates)); + ! HANDLED(actual_dates)); commodity_pool_t::current_pool->keep_base = HANDLED(base); commodity_pool_t::current_pool->get_quotes = session.HANDLED(download); @@ -96,7 +96,7 @@ void report_t::normalize_options(const string& verb) set_datetime_format(HANDLER(datetime_format_).str().c_str()); if (HANDLED(start_of_week_)) { if (optional<date_time::weekdays> weekday = - string_to_day_of_week(HANDLER(start_of_week_).str())) + string_to_day_of_week(HANDLER(start_of_week_).str())) start_of_week = *weekday; } @@ -106,24 +106,24 @@ void report_t::normalize_options(const string& verb) if (! HANDLED(meta_width_)) { string::size_type i = HANDLER(meta_).str().find(':'); if (i != string::npos) { - HANDLED(meta_width_).on_with - (string("?normalize"), - lexical_cast<long>(string(HANDLER(meta_).str(), i + 1))); - HANDLED(meta_).on(string("?normalize"), - string(HANDLER(meta_).str(), 0, i)); + HANDLED(meta_width_).on_with + (string("?normalize"), + lexical_cast<long>(string(HANDLER(meta_).str(), i + 1))); + HANDLED(meta_).on(string("?normalize"), + string(HANDLER(meta_).str(), 0, i)); } } if (HANDLED(meta_width_)) { HANDLER(prepend_format_).on - (string("?normalize"), - string("%(justify(truncated(tag(\"") + - HANDLER(meta_).str() + "\"), " + - HANDLED(meta_width_).value.to_string() + " - 1), " + - HANDLED(meta_width_).value.to_string() + "))"); + (string("?normalize"), + string("%(justify(truncated(tag(\"") + + HANDLER(meta_).str() + "\"), " + + HANDLED(meta_width_).value.to_string() + " - 1), " + + HANDLED(meta_width_).value.to_string() + "))"); meta_width = HANDLED(meta_width_).value.to_long(); } else { HANDLER(prepend_format_).on(string("?normalize"), string("%(tag(\"") + - HANDLER(meta_).str() + "\"))"); + HANDLER(meta_).str() + "\"))"); } } if (! HANDLED(prepend_width_)) @@ -183,7 +183,7 @@ void report_t::normalize_options(const string& verb) if (HANDLED(exchange_) && HANDLER(exchange_).str().find('=') != string::npos) { value_t(0L).exchange_commodities(HANDLER(exchange_).str(), true, - terminus); + terminus); } long cols = 0; @@ -202,22 +202,22 @@ void report_t::normalize_options(const string& verb) if (! HANDLER(date_width_).specified) HANDLER(date_width_) - .on_with(none, static_cast<long>(format_date(CURRENT_DATE(), - FMT_PRINTED).length())); + .on_with(none, static_cast<long>(format_date(CURRENT_DATE(), + FMT_PRINTED).length())); long date_width = HANDLER(date_width_).value.to_long(); long payee_width = (HANDLER(payee_width_).specified ? - HANDLER(payee_width_).value.to_long() : - int(double(cols) * 0.263157)); + HANDLER(payee_width_).value.to_long() : + int(double(cols) * 0.263157)); long account_width = (HANDLER(account_width_).specified ? - HANDLER(account_width_).value.to_long() : - int(double(cols) * 0.302631)); + HANDLER(account_width_).value.to_long() : + int(double(cols) * 0.302631)); long amount_width = (HANDLER(amount_width_).specified ? - HANDLER(amount_width_).value.to_long() : - int(double(cols) * 0.157894)); + HANDLER(amount_width_).value.to_long() : + int(double(cols) * 0.157894)); long total_width = (HANDLER(total_width_).specified ? - HANDLER(total_width_).value.to_long() : - amount_width); + HANDLER(total_width_).value.to_long() : + amount_width); DEBUG("auto.columns", "date_width = " << date_width); DEBUG("auto.columns", "payee_width = " << payee_width); @@ -226,16 +226,16 @@ void report_t::normalize_options(const string& verb) DEBUG("auto.columns", "total_width = " << total_width); if (! HANDLER(date_width_).specified && - ! HANDLER(payee_width_).specified && - ! HANDLER(account_width_).specified && - ! HANDLER(amount_width_).specified && - ! HANDLER(total_width_).specified) { + ! HANDLER(payee_width_).specified && + ! HANDLER(account_width_).specified && + ! HANDLER(amount_width_).specified && + ! HANDLER(total_width_).specified) { long total = (4 /* the spaces between */ + date_width + payee_width + - account_width + amount_width + total_width); + account_width + amount_width + total_width); if (total > cols) { - DEBUG("auto.columns", "adjusting account down"); - account_width -= total - cols; - DEBUG("auto.columns", "account_width now = " << account_width); + DEBUG("auto.columns", "adjusting account down"); + account_width -= total - cols; + DEBUG("auto.columns", "account_width now = " << account_width); } } @@ -261,7 +261,7 @@ void report_t::parse_query_args(const value_t& args, const string& whence) HANDLER(limit_).on(whence, query.text()); DEBUG("report.predicate", - "Predicate = " << HANDLER(limit_).str()); + "Predicate = " << HANDLER(limit_).str()); } if (query.tokens_remaining()) { @@ -270,7 +270,7 @@ void report_t::parse_query_args(const value_t& args, const string& whence) HANDLER(display_).on(whence, query.text()); DEBUG("report.predicate", - "Display predicate = " << HANDLER(display_).str()); + "Display predicate = " << HANDLER(display_).str()); } } } @@ -279,7 +279,7 @@ namespace { struct posts_flusher { post_handler_ptr handler; - report_t& report; + report_t& report; posts_flusher(post_handler_ptr _handler, report_t& _report) : handler(_handler), report(_report) {} @@ -335,7 +335,7 @@ namespace { struct accounts_title_printer { acct_handler_ptr handler; - report_t& report; + report_t& report; accounts_title_printer(acct_handler_ptr _handler, report_t& _report) : handler(_handler), report(_report) {} @@ -343,9 +343,9 @@ namespace { void operator()(const value_t& val) { if (! report.HANDLED(no_titles)) { - std::ostringstream buf; - val.print(buf); - handler->title(buf.str()); + std::ostringstream buf; + val.print(buf); + handler->title(buf.str()); } } }; @@ -353,7 +353,7 @@ namespace { struct accounts_flusher { acct_handler_ptr handler; - report_t& report; + report_t& report; accounts_flusher(acct_handler_ptr _handler, report_t& _report) : handler(_handler), report(_report) {} @@ -368,23 +368,23 @@ namespace { scoped_ptr<accounts_iterator> iter; if (! report.HANDLED(sort_)) { - iter.reset(new basic_accounts_iterator(*report.session.journal->master)); + iter.reset(new basic_accounts_iterator(*report.session.journal->master)); } else { - expr_t sort_expr(report.HANDLER(sort_).str()); - sort_expr.set_context(&report); - iter.reset(new sorted_accounts_iterator(*report.session.journal->master, - sort_expr, report.HANDLED(flat))); + expr_t sort_expr(report.HANDLER(sort_).str()); + sort_expr.set_context(&report); + iter.reset(new sorted_accounts_iterator(*report.session.journal->master, + sort_expr, report.HANDLED(flat))); } if (report.HANDLED(display_)) { - DEBUG("report.predicate", - "Display predicate = " << report.HANDLER(display_).str()); - pass_down_accounts(handler, *iter.get(), - predicate_t(report.HANDLER(display_).str(), - report.what_to_keep()), - report); + DEBUG("report.predicate", + "Display predicate = " << report.HANDLER(display_).str()); + pass_down_accounts(handler, *iter.get(), + predicate_t(report.HANDLER(display_).str(), + report.what_to_keep()), + report); } else { - pass_down_accounts(handler, *iter.get()); + pass_down_accounts(handler, *iter.get()); } report.session.journal->clear_xdata(); @@ -396,7 +396,7 @@ void report_t::accounts_report(acct_handler_ptr handler) { post_handler_ptr chain = chain_post_handlers(post_handler_ptr(new ignore_posts), *this, - /* for_accounts_report= */ true); + /* for_accounts_report= */ true); if (HANDLED(group_by_)) { std::auto_ptr<post_splitter> splitter(new post_splitter(chain, *this, HANDLER(group_by_).expr)); @@ -454,12 +454,12 @@ value_t report_t::fn_market(call_scope_t& scope) value_t result; optional<datetime_t> moment = (args.has(1) ? - args.get<datetime_t>(1) : - optional<datetime_t>()); + args.get<datetime_t>(1) : + optional<datetime_t>()); if (args.has(2)) result = args.value_at(0).exchange_commodities(args.get<string>(2), - /* add_prices= */ false, - moment); + /* add_prices= */ false, + moment); else result = args.value_at(0).value(moment); @@ -482,8 +482,8 @@ value_t report_t::fn_get_at(call_scope_t& scope) } else { if (! args.value_at(0).is_sequence()) throw_(std::runtime_error, - _("Attempting to get argument at index %1 from %2") - << args.get<long>(1) << args.value_at(0).label()); + _("Attempting to get argument at index %1 from %2") + << args.get<long>(1) << args.value_at(0).label()); } return args.get<const value_t::sequence_t&>(0)[args.get<long>(1)]; } @@ -584,9 +584,9 @@ value_t report_t::fn_truncated(call_scope_t& scope) { interactive_t args(scope, "v&ll"); return string_value(format_t::truncate - (args.get<string>(0), - args.has(1) && args.get<int>(1) > 0 ? args.get<int>(1) : 0, - args.has(2) ? args.get<int>(2) : 0)); + (args.get<string>(0), + args.has(1) && args.get<int>(1) > 0 ? args.get<int>(1) : 0, + args.has(2) ? args.get<int>(2) : 0)); } value_t report_t::fn_justify(call_scope_t& scope) @@ -608,7 +608,7 @@ value_t report_t::fn_justify(call_scope_t& scope) value_t report_t::fn_quoted(call_scope_t& scope) { - interactive_t args(scope, "v"); + interactive_t args(scope, "v"); std::ostringstream out; out << '"'; @@ -625,7 +625,7 @@ value_t report_t::fn_quoted(call_scope_t& scope) value_t report_t::fn_join(call_scope_t& scope) { - interactive_t args(scope, "s"); + interactive_t args(scope, "s"); std::ostringstream out; foreach (const char ch, args.get<string>(0)) { @@ -642,7 +642,7 @@ value_t report_t::fn_format_date(call_scope_t& scope) interactive_t args(scope, "d&s"); if (args.has(1)) return string_value(format_date(args.get<date_t>(0), FMT_CUSTOM, - args.get<string>(1).c_str())); + args.get<string>(1).c_str())); else return string_value(format_date(args.get<date_t>(0), FMT_PRINTED)); } @@ -654,17 +654,17 @@ value_t report_t::fn_ansify_if(call_scope_t& scope) if (args.has(1)) { string color = args.get<string>(1); std::ostringstream buf; - if (color == "black") buf << "\033[30m"; - else if (color == "red") buf << "\033[31m"; - else if (color == "green") buf << "\033[32m"; - else if (color == "yellow") buf << "\033[33m"; - else if (color == "blue") buf << "\033[34m"; + if (color == "black") buf << "\033[30m"; + else if (color == "red") buf << "\033[31m"; + else if (color == "green") buf << "\033[32m"; + else if (color == "yellow") buf << "\033[33m"; + else if (color == "blue") buf << "\033[34m"; else if (color == "magenta") buf << "\033[35m"; - else if (color == "cyan") buf << "\033[36m"; - else if (color == "white") buf << "\033[37m"; - else if (color == "bold") buf << "\033[1m"; + else if (color == "cyan") buf << "\033[36m"; + else if (color == "white") buf << "\033[37m"; + else if (color == "bold") buf << "\033[1m"; else if (color == "underline") buf << "\033[4m"; - else if (color == "blink") buf << "\033[5m"; + else if (color == "blink") buf << "\033[5m"; buf << args.value_at(0); buf << "\033[0m"; return string_value(buf.str()); @@ -677,7 +677,7 @@ value_t report_t::fn_percent(call_scope_t& scope) { interactive_t args(scope, "aa"); return (amount_t("100.00%") * - (args.get<amount_t>(0) / args.get<amount_t>(1)).number()); + (args.get<amount_t>(0) / args.get<amount_t>(1)).number()); } value_t report_t::fn_price(call_scope_t& scope) @@ -1094,13 +1094,13 @@ option_t<report_t> * report_t::lookup_option(const char * p) } void report_t::define(const symbol_t::kind_t kind, const string& name, - expr_t::ptr_op_t def) + expr_t::ptr_op_t def) { session.define(kind, name, def); } expr_t::ptr_op_t report_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (expr_t::ptr_op_t def = session.lookup(kind, name)) return def; @@ -1114,208 +1114,208 @@ expr_t::ptr_op_t report_t::lookup(const symbol_t::kind_t kind, switch (*p) { case 'd': case 'm': - return MAKE_FUNCTOR(report_t::fn_now); + return MAKE_FUNCTOR(report_t::fn_now); case 'P': - return MAKE_FUNCTOR(report_t::fn_market); + return MAKE_FUNCTOR(report_t::fn_market); case 't': - return MAKE_FUNCTOR(report_t::fn_display_amount); + return MAKE_FUNCTOR(report_t::fn_display_amount); case 'T': - return MAKE_FUNCTOR(report_t::fn_display_total); + return MAKE_FUNCTOR(report_t::fn_display_total); case 'U': - return MAKE_FUNCTOR(report_t::fn_abs); + return MAKE_FUNCTOR(report_t::fn_abs); case 'S': - return MAKE_FUNCTOR(report_t::fn_strip); + return MAKE_FUNCTOR(report_t::fn_strip); case 'i': - throw_(std::runtime_error, - _("The i value expression variable is no longer supported")); + throw_(std::runtime_error, + _("The i value expression variable is no longer supported")); case 'A': - throw_(std::runtime_error, - _("The A value expression variable is no longer supported")); + throw_(std::runtime_error, + _("The A value expression variable is no longer supported")); case 'v': case 'V': - throw_(std::runtime_error, - _("The V and v value expression variables are no longer supported")); + throw_(std::runtime_error, + _("The V and v value expression variables are no longer supported")); case 'I': case 'B': - throw_(std::runtime_error, - _("The I and B value expression variables are no longer supported")); + throw_(std::runtime_error, + _("The I and B value expression variables are no longer supported")); case 'g': case 'G': - throw_(std::runtime_error, - _("The G and g value expression variables are no longer supported")); + throw_(std::runtime_error, + _("The G and g value expression variables are no longer supported")); default: - return NULL; + return NULL; } } switch (*p) { case 'a': if (is_eq(p, "amount_expr")) - return MAKE_FUNCTOR(report_t::fn_amount_expr); + return MAKE_FUNCTOR(report_t::fn_amount_expr); else if (is_eq(p, "ansify_if")) - return MAKE_FUNCTOR(report_t::fn_ansify_if); + return MAKE_FUNCTOR(report_t::fn_ansify_if); else if (is_eq(p, "abs")) - return MAKE_FUNCTOR(report_t::fn_abs); + return MAKE_FUNCTOR(report_t::fn_abs); break; case 'b': if (is_eq(p, "black")) - return WRAP_FUNCTOR(fn_black); + return WRAP_FUNCTOR(fn_black); else if (is_eq(p, "blink")) - return WRAP_FUNCTOR(fn_blink); + return WRAP_FUNCTOR(fn_blink); else if (is_eq(p, "blue")) - return WRAP_FUNCTOR(fn_blue); + return WRAP_FUNCTOR(fn_blue); else if (is_eq(p, "bold")) - return WRAP_FUNCTOR(fn_bold); + return WRAP_FUNCTOR(fn_bold); break; case 'c': if (is_eq(p, "cyan")) - return WRAP_FUNCTOR(fn_cyan); + return WRAP_FUNCTOR(fn_cyan); break; case 'd': if (is_eq(p, "display_amount")) - return MAKE_FUNCTOR(report_t::fn_display_amount); + return MAKE_FUNCTOR(report_t::fn_display_amount); else if (is_eq(p, "display_total")) - return MAKE_FUNCTOR(report_t::fn_display_total); + return MAKE_FUNCTOR(report_t::fn_display_total); else if (is_eq(p, "date")) - return MAKE_FUNCTOR(report_t::fn_now); + return MAKE_FUNCTOR(report_t::fn_now); break; case 'f': if (is_eq(p, "format_date")) - return MAKE_FUNCTOR(report_t::fn_format_date); + return MAKE_FUNCTOR(report_t::fn_format_date); else if (is_eq(p, "floor")) - return MAKE_FUNCTOR(report_t::fn_floor); + return MAKE_FUNCTOR(report_t::fn_floor); break; case 'g': if (is_eq(p, "get_at")) - return MAKE_FUNCTOR(report_t::fn_get_at); + return MAKE_FUNCTOR(report_t::fn_get_at); else if (is_eq(p, "green")) - return WRAP_FUNCTOR(fn_green); + return WRAP_FUNCTOR(fn_green); break; case 'i': if (is_eq(p, "is_seq")) - return MAKE_FUNCTOR(report_t::fn_is_seq); + return MAKE_FUNCTOR(report_t::fn_is_seq); break; case 'j': if (is_eq(p, "justify")) - return MAKE_FUNCTOR(report_t::fn_justify); + return MAKE_FUNCTOR(report_t::fn_justify); else if (is_eq(p, "join")) - return MAKE_FUNCTOR(report_t::fn_join); + return MAKE_FUNCTOR(report_t::fn_join); break; case 'm': if (is_eq(p, "market")) - return MAKE_FUNCTOR(report_t::fn_market); + return MAKE_FUNCTOR(report_t::fn_market); else if (is_eq(p, "magenta")) - return WRAP_FUNCTOR(fn_magenta); + return WRAP_FUNCTOR(fn_magenta); break; case 'n': if (is_eq(p, "null")) - return WRAP_FUNCTOR(fn_null); + return WRAP_FUNCTOR(fn_null); else if (is_eq(p, "now")) - return MAKE_FUNCTOR(report_t::fn_now); + return MAKE_FUNCTOR(report_t::fn_now); break; case 'o': if (is_eq(p, "options")) - return MAKE_FUNCTOR(report_t::fn_options); + return MAKE_FUNCTOR(report_t::fn_options); break; case 'p': if (is_eq(p, "post")) - return WRAP_FUNCTOR(fn_false); + return WRAP_FUNCTOR(fn_false); else if (is_eq(p, "percent")) - return MAKE_FUNCTOR(report_t::fn_percent); + return MAKE_FUNCTOR(report_t::fn_percent); else if (is_eq(p, "price")) - return MAKE_FUNCTOR(report_t::fn_price); + return MAKE_FUNCTOR(report_t::fn_price); else if (is_eq(p, "print")) - return MAKE_FUNCTOR(report_t::fn_print); + return MAKE_FUNCTOR(report_t::fn_print); break; case 'q': if (is_eq(p, "quoted")) - return MAKE_FUNCTOR(report_t::fn_quoted); + return MAKE_FUNCTOR(report_t::fn_quoted); else if (is_eq(p, "quantity")) - return MAKE_FUNCTOR(report_t::fn_quantity); + return MAKE_FUNCTOR(report_t::fn_quantity); break; case 'r': if (is_eq(p, "rounded")) - return MAKE_FUNCTOR(report_t::fn_rounded); + return MAKE_FUNCTOR(report_t::fn_rounded); else if (is_eq(p, "red")) - return WRAP_FUNCTOR(fn_red); + return WRAP_FUNCTOR(fn_red); break; case 's': if (is_eq(p, "scrub")) - return MAKE_FUNCTOR(report_t::fn_scrub); + return MAKE_FUNCTOR(report_t::fn_scrub); else if (is_eq(p, "strip")) - return MAKE_FUNCTOR(report_t::fn_strip); + return MAKE_FUNCTOR(report_t::fn_strip); break; case 't': if (is_eq(p, "truncated")) - return MAKE_FUNCTOR(report_t::fn_truncated); + return MAKE_FUNCTOR(report_t::fn_truncated); else if (is_eq(p, "total_expr")) - return MAKE_FUNCTOR(report_t::fn_total_expr); + return MAKE_FUNCTOR(report_t::fn_total_expr); else if (is_eq(p, "today")) - return MAKE_FUNCTOR(report_t::fn_today); + return MAKE_FUNCTOR(report_t::fn_today); else if (is_eq(p, "t")) - return MAKE_FUNCTOR(report_t::fn_display_amount); + return MAKE_FUNCTOR(report_t::fn_display_amount); else if (is_eq(p, "trim")) - return MAKE_FUNCTOR(report_t::fn_trim); + return MAKE_FUNCTOR(report_t::fn_trim); else if (is_eq(p, "to_boolean")) - return MAKE_FUNCTOR(report_t::fn_to_boolean); + return MAKE_FUNCTOR(report_t::fn_to_boolean); else if (is_eq(p, "to_int")) - return MAKE_FUNCTOR(report_t::fn_to_int); + return MAKE_FUNCTOR(report_t::fn_to_int); else if (is_eq(p, "to_datetime")) - return MAKE_FUNCTOR(report_t::fn_to_datetime); + return MAKE_FUNCTOR(report_t::fn_to_datetime); else if (is_eq(p, "to_date")) - return MAKE_FUNCTOR(report_t::fn_to_date); + return MAKE_FUNCTOR(report_t::fn_to_date); else if (is_eq(p, "to_amount")) - return MAKE_FUNCTOR(report_t::fn_to_amount); + return MAKE_FUNCTOR(report_t::fn_to_amount); else if (is_eq(p, "to_balance")) - return MAKE_FUNCTOR(report_t::fn_to_balance); + return MAKE_FUNCTOR(report_t::fn_to_balance); else if (is_eq(p, "to_string")) - return MAKE_FUNCTOR(report_t::fn_to_string); + return MAKE_FUNCTOR(report_t::fn_to_string); else if (is_eq(p, "to_mask")) - return MAKE_FUNCTOR(report_t::fn_to_mask); + return MAKE_FUNCTOR(report_t::fn_to_mask); else if (is_eq(p, "to_sequence")) - return MAKE_FUNCTOR(report_t::fn_to_sequence); + return MAKE_FUNCTOR(report_t::fn_to_sequence); break; case 'T': if (is_eq(p, "T")) - return MAKE_FUNCTOR(report_t::fn_display_total); + return MAKE_FUNCTOR(report_t::fn_display_total); break; case 'u': if (is_eq(p, "underline")) - return WRAP_FUNCTOR(fn_underline); + return WRAP_FUNCTOR(fn_underline); else if (is_eq(p, "unrounded")) - return MAKE_FUNCTOR(report_t::fn_unrounded); + return MAKE_FUNCTOR(report_t::fn_unrounded); break; case 'v': if (is_eq(p, "value_date")) - return MAKE_FUNCTOR(report_t::fn_now); + return MAKE_FUNCTOR(report_t::fn_now); break; case 'w': if (is_eq(p, "white")) - return WRAP_FUNCTOR(fn_white); + return WRAP_FUNCTOR(fn_white); break; case 'y': if (is_eq(p, "yellow")) - return WRAP_FUNCTOR(fn_yellow); + return WRAP_FUNCTOR(fn_yellow); break; } @@ -1333,135 +1333,135 @@ expr_t::ptr_op_t report_t::lookup(const symbol_t::kind_t kind, switch (*p) { case 'a': if (is_eq(p, "accounts")) { - return WRAP_FUNCTOR(reporter<>(new report_accounts(*this), *this, - "#accounts")); + return WRAP_FUNCTOR(reporter<>(new report_accounts(*this), *this, + "#accounts")); } break; case 'b': if (*(p + 1) == '\0' || is_eq(p, "bal") || is_eq(p, "balance")) { - return expr_t::op_t::wrap_functor - (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> - (new format_accounts(*this, report_format(HANDLER(balance_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#balance")); + return expr_t::op_t::wrap_functor + (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> + (new format_accounts(*this, report_format(HANDLER(balance_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#balance")); } else if (is_eq(p, "budget")) { - HANDLER(amount_).set_expr(string("#budget"), "(amount, 0)"); - - budget_flags |= BUDGET_WRAP_VALUES; - if (! (budget_flags & ~BUDGET_WRAP_VALUES)) - budget_flags |= BUDGET_BUDGETED; - - return expr_t::op_t::wrap_functor - (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> - (new format_accounts(*this, report_format(HANDLER(budget_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#budget")); + HANDLER(amount_).set_expr(string("#budget"), "(amount, 0)"); + + budget_flags |= BUDGET_WRAP_VALUES; + if (! (budget_flags & ~BUDGET_WRAP_VALUES)) + budget_flags |= BUDGET_BUDGETED; + + return expr_t::op_t::wrap_functor + (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> + (new format_accounts(*this, report_format(HANDLER(budget_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#budget")); } break; case 'c': if (is_eq(p, "csv")) { - return WRAP_FUNCTOR - (reporter<> - (new format_posts(*this, report_format(HANDLER(csv_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#csv")); + return WRAP_FUNCTOR + (reporter<> + (new format_posts(*this, report_format(HANDLER(csv_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#csv")); } else if (is_eq(p, "cleared")) { - HANDLER(amount_).set_expr(string("#cleared"), - "(amount, cleared ? amount : 0)"); - return expr_t::op_t::wrap_functor - (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> - (new format_accounts(*this, report_format(HANDLER(cleared_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#cleared")); + HANDLER(amount_).set_expr(string("#cleared"), + "(amount, cleared ? amount : 0)"); + return expr_t::op_t::wrap_functor + (reporter<account_t, acct_handler_ptr, &report_t::accounts_report> + (new format_accounts(*this, report_format(HANDLER(cleared_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#cleared")); } else if (is_eq(p, "convert")) { - return WRAP_FUNCTOR(convert_command); + return WRAP_FUNCTOR(convert_command); } else if (is_eq(p, "commodities")) { - return WRAP_FUNCTOR(reporter<>(new report_commodities(*this), *this, - "#commodities")); + return WRAP_FUNCTOR(reporter<>(new report_commodities(*this), *this, + "#commodities")); } break; case 'e': if (is_eq(p, "equity")) { - HANDLER(generated).on_only(string("#equity")); - return WRAP_FUNCTOR(reporter<>(new print_xacts(*this), *this, "#equity")); + HANDLER(generated).on_only(string("#equity")); + return WRAP_FUNCTOR(reporter<>(new print_xacts(*this), *this, "#equity")); } else if (is_eq(p, "entry")) { - return WRAP_FUNCTOR(xact_command); + return WRAP_FUNCTOR(xact_command); } else if (is_eq(p, "emacs")) { - return WRAP_FUNCTOR - (reporter<>(new format_emacs_posts(output_stream), *this, "#emacs")); + return WRAP_FUNCTOR + (reporter<>(new format_emacs_posts(output_stream), *this, "#emacs")); } else if (is_eq(p, "echo")) { - return MAKE_FUNCTOR(report_t::echo_command); + return MAKE_FUNCTOR(report_t::echo_command); } break; case 'p': if (*(p + 1) == '\0' || is_eq(p, "print")) { - return WRAP_FUNCTOR - (reporter<>(new print_xacts(*this, HANDLED(raw)), *this, "#print")); + return WRAP_FUNCTOR + (reporter<>(new print_xacts(*this, HANDLED(raw)), *this, "#print")); } else if (is_eq(p, "prices")) { - return expr_t::op_t::wrap_functor - (reporter<post_t, post_handler_ptr, &report_t::commodities_report> - (new format_posts(*this, report_format(HANDLER(prices_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#prices")); + return expr_t::op_t::wrap_functor + (reporter<post_t, post_handler_ptr, &report_t::commodities_report> + (new format_posts(*this, report_format(HANDLER(prices_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#prices")); } else if (is_eq(p, "pricedb")) { - return expr_t::op_t::wrap_functor - (reporter<post_t, post_handler_ptr, &report_t::commodities_report> - (new format_posts(*this, report_format(HANDLER(pricedb_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#pricedb")); + return expr_t::op_t::wrap_functor + (reporter<post_t, post_handler_ptr, &report_t::commodities_report> + (new format_posts(*this, report_format(HANDLER(pricedb_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#pricedb")); } else if (is_eq(p, "pricemap")) { - return MAKE_FUNCTOR(report_t::pricemap_command); + return MAKE_FUNCTOR(report_t::pricemap_command); } else if (is_eq(p, "payees")) { - return WRAP_FUNCTOR(reporter<>(new report_payees(*this), *this, - "#payees")); + return WRAP_FUNCTOR(reporter<>(new report_payees(*this), *this, + "#payees")); } break; case 'r': if (*(p + 1) == '\0' || is_eq(p, "reg") || is_eq(p, "register")) { - return WRAP_FUNCTOR - (reporter<> - (new format_posts(*this, report_format(HANDLER(register_format_)), - maybe_format(HANDLER(prepend_format_)), - HANDLER(prepend_width_).value.to_long()), - *this, "#register")); + return WRAP_FUNCTOR + (reporter<> + (new format_posts(*this, report_format(HANDLER(register_format_)), + maybe_format(HANDLER(prepend_format_)), + HANDLER(prepend_width_).value.to_long()), + *this, "#register")); } else if (is_eq(p, "reload")) { - return MAKE_FUNCTOR(report_t::reload_command); + return MAKE_FUNCTOR(report_t::reload_command); } break; case 's': if (is_eq(p, "stats") || is_eq(p, "stat")) - return WRAP_FUNCTOR(report_statistics); + return WRAP_FUNCTOR(report_statistics); break; case 'x': if (is_eq(p, "xact")) - return WRAP_FUNCTOR(xact_command); + return WRAP_FUNCTOR(xact_command); else if (is_eq(p, "xml")) - return WRAP_FUNCTOR(reporter<>(new format_xml(*this), *this, "#xml")); + return WRAP_FUNCTOR(reporter<>(new format_xml(*this), *this, "#xml")); break; } break; @@ -1470,38 +1470,38 @@ expr_t::ptr_op_t report_t::lookup(const symbol_t::kind_t kind, switch (*p) { case 'a': if (is_eq(p, "args")) - return WRAP_FUNCTOR(query_command); + return WRAP_FUNCTOR(query_command); break; case 'e': if (is_eq(p, "eval")) - return WRAP_FUNCTOR(eval_command); + return WRAP_FUNCTOR(eval_command); else if (is_eq(p, "expr")) - return WRAP_FUNCTOR(parse_command); + return WRAP_FUNCTOR(parse_command); break; case 'f': if (is_eq(p, "format")) - return WRAP_FUNCTOR(format_command); + return WRAP_FUNCTOR(format_command); break; case 'g': if (is_eq(p, "generate")) { - return expr_t::op_t::wrap_functor - (reporter<post_t, post_handler_ptr, &report_t::generate_report> - (new print_xacts(*this), *this, "#generate")); + return expr_t::op_t::wrap_functor + (reporter<post_t, post_handler_ptr, &report_t::generate_report> + (new print_xacts(*this), *this, "#generate")); } break; case 'p': if (is_eq(p, "parse")) - return WRAP_FUNCTOR(parse_command); + return WRAP_FUNCTOR(parse_command); else if (is_eq(p, "period")) - return WRAP_FUNCTOR(period_command); + return WRAP_FUNCTOR(period_command); break; case 'q': if (is_eq(p, "query")) - return WRAP_FUNCTOR(query_command); + return WRAP_FUNCTOR(query_command); break; case 't': if (is_eq(p, "template")) - return WRAP_FUNCTOR(template_command); + return WRAP_FUNCTOR(template_command); break; } break; diff --git a/src/report.h b/src/report.h index 9e70551f..f1a213c1 100644 --- a/src/report.h +++ b/src/report.h @@ -107,11 +107,11 @@ class report_t : public scope_t report_t(); public: - session_t& session; + session_t& session; output_stream_t output_stream; #define BUDGET_NO_BUDGET 0x00 -#define BUDGET_BUDGETED 0x01 +#define BUDGET_BUDGETED 0x01 #define BUDGET_UNBUDGETED 0x02 #define BUDGET_WRAP_VALUES 0x04 @@ -203,9 +203,9 @@ public: keep_details_t what_to_keep() { bool lots = HANDLED(lots) || HANDLED(lots_actual); return keep_details_t(lots || HANDLED(lot_prices), - lots || HANDLED(lot_dates), - lots || HANDLED(lot_tags), - HANDLED(lots_actual)); + lots || HANDLED(lot_dates), + lots || HANDLED(lot_tags), + HANDLED(lots_actual)); } void report_options(std::ostream& out) @@ -331,17 +331,17 @@ public: option_t<report_t> * lookup_option(const char * p); virtual void define(const symbol_t::kind_t kind, const string& name, - expr_t::ptr_op_t def); + expr_t::ptr_op_t def); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); /** * Option handlers */ OPTION__(report_t, abbrev_len_, - CTOR(report_t, abbrev_len_) { on_with(none, 2L); }); + CTOR(report_t, abbrev_len_) { on_with(none, 2L); }); OPTION(report_t, account_); OPTION_(report_t, actual, DO() { // -L @@ -373,16 +373,16 @@ public: OPTION_(report_t, average, DO() { // -A parent->HANDLER(display_total_) - .set_expr(string("--average"), "count>0?(total_expr/count):0"); + .set_expr(string("--average"), "count>0?(total_expr/count):0"); }); OPTION__(report_t, balance_format_, CTOR(report_t, balance_format_) { on(none, - "%(justify(scrub(display_total), 20, 20 + prepend_width, true, color))" - " %(!options.flat ? depth_spacer : \"\")" - "%-(ansify_if(partial_account(options.flat), blue if color))\n%/" - "%$1\n%/" - "--------------------\n"); + "%(justify(scrub(display_total), 20, 20 + prepend_width, true, color))" + " %(!options.flat ? depth_spacer : \"\")" + "%-(ansify_if(partial_account(options.flat), blue if color))\n%/" + "%$1\n%/" + "--------------------\n"); }); OPTION(report_t, base); @@ -396,9 +396,9 @@ public: date_interval_t interval(args[1].to_string()); optional<date_t> begin = interval.begin(parent->session.current_year); if (! begin) - throw_(std::invalid_argument, - _("Could not determine beginning of period '%1'") - << args[1].to_string()); + throw_(std::invalid_argument, + _("Could not determine beginning of period '%1'") + << args[1].to_string()); string predicate = "date>=[" + to_iso_extended_string(*begin) + "]"; parent->HANDLER(limit_).on(string("--begin"), predicate); @@ -410,24 +410,24 @@ public: OPTION__(report_t, budget_format_, CTOR(report_t, budget_format_) { on(none, - "%(justify(scrub(get_at(total_expr, 0)), 12, -1, true, color))" - " %(justify(-scrub(get_at(total_expr, 1)), 12, " - " 12 + 1 + 12, true, color))" - " %(justify(scrub(get_at(total_expr, 1) + " - " get_at(total_expr, 0)), 12, " - " 12 + 1 + 12 + 1 + 12, true, color))" - " %(ansify_if(" - " justify((get_at(total_expr, 1) ? " - " (100% * scrub(get_at(total_expr, 0))) / " - " -scrub(get_at(total_expr, 1)) : 0), " - " 5, -1, true, false)," - " magenta if (color and get_at(total_expr, 1) and " - " (abs(quantity(scrub(get_at(total_expr, 0))) / " - " quantity(scrub(get_at(total_expr, 1)))) >= 1))))" - " %(!options.flat ? depth_spacer : \"\")" - "%-(ansify_if(partial_account(options.flat), blue if color))\n" - "%/%$1 %$2 %$3 %$4\n%/" - "------------ ------------ ------------ -----\n"); + "%(justify(scrub(get_at(total_expr, 0)), 12, -1, true, color))" + " %(justify(-scrub(get_at(total_expr, 1)), 12, " + " 12 + 1 + 12, true, color))" + " %(justify(scrub(get_at(total_expr, 1) + " + " get_at(total_expr, 0)), 12, " + " 12 + 1 + 12 + 1 + 12, true, color))" + " %(ansify_if(" + " justify((get_at(total_expr, 1) ? " + " (100% * scrub(get_at(total_expr, 0))) / " + " -scrub(get_at(total_expr, 1)) : 0), " + " 5, -1, true, false)," + " magenta if (color and get_at(total_expr, 1) and " + " (abs(quantity(scrub(get_at(total_expr, 0))) / " + " quantity(scrub(get_at(total_expr, 1)))) >= 1))))" + " %(!options.flat ? depth_spacer : \"\")" + "%-(ansify_if(partial_account(options.flat), blue if color))\n" + "%/%$1 %$2 %$3 %$4\n%/" + "------------ ------------ ------------ -----\n"); }); OPTION(report_t, by_payee); // -P @@ -438,14 +438,14 @@ public: OPTION__(report_t, cleared_format_, CTOR(report_t, cleared_format_) { on(none, - "%(justify(scrub(get_at(total_expr, 0)), 16, 16 + prepend_width, " - " true, color)) %(justify(scrub(get_at(total_expr, 1)), 18, " - " 36 + prepend_width, true, color))" - " %(latest_cleared ? format_date(latest_cleared) : \" \")" - " %(!options.flat ? depth_spacer : \"\")" - "%-(ansify_if(partial_account(options.flat), blue if color))\n%/" - "%$1 %$2 %$3\n%/" - "---------------- ---------------- ---------\n"); + "%(justify(scrub(get_at(total_expr, 0)), 16, 16 + prepend_width, " + " true, color)) %(justify(scrub(get_at(total_expr, 1)), 18, " + " 36 + prepend_width, true, color))" + " %(latest_cleared ? format_date(latest_cleared) : \" \")" + " %(!options.flat ? depth_spacer : \"\")" + "%-(ansify_if(partial_account(options.flat), blue if color))\n%/" + "%$1 %$2 %$3\n%/" + "---------------- ---------------- ---------\n"); }); OPTION(report_t, color); @@ -465,14 +465,14 @@ public: OPTION__(report_t, csv_format_, CTOR(report_t, csv_format_) { on(none, - "%(quoted(date))," - "%(quoted(code))," - "%(quoted(payee))," - "%(quoted(display_account))," - "%(quoted(commodity))," - "%(quoted(quantity(scrub(display_amount))))," - "%(quoted(cleared ? \"*\" : (pending ? \"!\" : \"\")))," - "%(quoted(join(note | xact.note)))\n"); + "%(quoted(date))," + "%(quoted(code))," + "%(quoted(payee))," + "%(quoted(display_account))," + "%(quoted(commodity))," + "%(quoted(quantity(scrub(display_amount))))," + "%(quoted(cleared ? \"*\" : (pending ? \"!\" : \"\")))," + "%(quoted(join(note | xact.note)))\n"); }); OPTION_(report_t, current, DO() { // -c @@ -490,12 +490,12 @@ public: OPTION_(report_t, depth_, DO_(scope) { interactive_t args(scope, "sl"); parent->HANDLER(display_).on(string("--depth"), - string("depth<=") + args.get<string>(1)); + string("depth<=") + args.get<string>(1)); }); OPTION_(report_t, deviation, DO() { parent->HANDLER(display_total_) - .set_expr(string("--deviation"), "amount_expr-total_expr/count"); + .set_expr(string("--deviation"), "amount_expr-total_expr/count"); }); OPTION__ @@ -506,8 +506,8 @@ public: option_t<report_t>::on_with(whence, text); else option_t<report_t>::on_with(whence, - string_value(string("(") + str() + ")&(" + - text.as_string() + ")")); + string_value(string("(") + str() + ")&(" + + text.as_string() + ")")); }); OPTION__ @@ -548,9 +548,9 @@ public: // 2008/01/01 instead of 2009/01/01 (which is what end() would return). optional<date_t> end = interval.begin(parent->session.current_year); if (! end) - throw_(std::invalid_argument, - _("Could not determine end of period '%1'") - << args[1].to_string()); + throw_(std::invalid_argument, + _("Could not determine end of period '%1'") + << args[1].to_string()); string predicate = "date<[" + to_iso_extended_string(*end) + "]"; parent->HANDLER(limit_).on(string("--end"), predicate); @@ -582,21 +582,21 @@ public: // Since we are displaying the amounts of revalued postings, they // will end up being composite totals, and hence a pair of pairs. parent->HANDLER(display_amount_) - .set_expr(string("--gain"), - "use_direct_amount ? amount :" - " (is_seq(get_at(amount_expr, 0)) ?" - " get_at(get_at(amount_expr, 0), 0) :" - " market(get_at(amount_expr, 0), value_date, exchange)" - " - get_at(amount_expr, 1))"); + .set_expr(string("--gain"), + "use_direct_amount ? amount :" + " (is_seq(get_at(amount_expr, 0)) ?" + " get_at(get_at(amount_expr, 0), 0) :" + " market(get_at(amount_expr, 0), value_date, exchange)" + " - get_at(amount_expr, 1))"); parent->HANDLER(revalued_total_) - .set_expr(string("--gain"), - "(market(get_at(total_expr, 0), value_date, exchange), " - "get_at(total_expr, 1))"); + .set_expr(string("--gain"), + "(market(get_at(total_expr, 0), value_date, exchange), " + "get_at(total_expr, 1))"); parent->HANDLER(display_total_) - .set_expr(string("--gain"), - "use_direct_amount ? total_expr :" - " market(get_at(total_expr, 0), value_date, exchange)" - " - get_at(total_expr, 1)"); + .set_expr(string("--gain"), + "use_direct_amount ? total_expr :" + " market(get_at(total_expr, 0), value_date, exchange)" + " - get_at(total_expr, 1)"); }); OPTION(report_t, generated); @@ -631,8 +631,8 @@ public: option_t<report_t>::on_with(whence, text); else option_t<report_t>::on_with(whence, - string_value(string("(") + str() + ")&(" + - text.as_string() + ")")); + string_value(string("(") + str() + ")&(" + + text.as_string() + ")")); }); OPTION(report_t, lot_dates); @@ -644,11 +644,11 @@ public: OPTION_(report_t, market, DO() { // -V parent->HANDLER(revalued).on_only(string("--market")); parent->HANDLER(display_amount_) - .set_expr(string("--market"), - "market(amount_expr, value_date, exchange)"); + .set_expr(string("--market"), + "market(amount_expr, value_date, exchange)"); parent->HANDLER(display_total_) - .set_expr(string("--market"), - "market(total_expr, value_date, exchange)"); + .set_expr(string("--market"), + "market(total_expr, value_date, exchange)"); }); OPTION(report_t, meta_); @@ -669,9 +669,9 @@ public: date_interval_t interval(args[1].to_string()); optional<date_t> begin = interval.begin(parent->session.current_year); if (! begin) - throw_(std::invalid_argument, - _("Could not determine beginning of period '%1'") - << args[1].to_string()); + throw_(std::invalid_argument, + _("Could not determine beginning of period '%1'") + << args[1].to_string()); ledger::epoch = parent->terminus = datetime_t(*begin); parent->session.current_year = ledger::epoch->date().year(); }); @@ -684,8 +684,8 @@ public: option_t<report_t>::on_with(whence, text); else option_t<report_t>::on_with(whence, - string_value(string("(") + str() + ")&(" + - text.as_string() + ")")); + string_value(string("(") + str() + ")&(" + + text.as_string() + ")")); }); OPTION(report_t, output_); // -o @@ -697,20 +697,20 @@ public: if (! std::getenv("PAGER") && isatty(STDOUT_FILENO)) { bool have_less = false; if (exists(path("/opt/local/bin/less")) || - exists(path("/usr/local/bin/less")) || - exists(path("/usr/bin/less"))) - have_less = true; + exists(path("/usr/local/bin/less")) || + exists(path("/usr/bin/less"))) + have_less = true; if (have_less) { - on(none, "less"); - setenv("LESS", "-FRSX", 0); // don't overwrite + on(none, "less"); + setenv("LESS", "-FRSX", 0); // don't overwrite } } } virtual void on_with(const optional<string>& whence, const value_t& text) { string cmd(text.to_string()); if (cmd == "" || cmd == "false" || cmd == "off" || - cmd == "none" || cmd == "no" || cmd == "disable") + cmd == "none" || cmd == "no" || cmd == "disable") option_t<report_t>::off(); else option_t<report_t>::on_with(whence, text); @@ -723,7 +723,7 @@ public: virtual void on_with(const optional<string>& whence, const value_t& text) { string cmd(text.to_string()); if (cmd == "" || cmd == "false" || cmd == "off" || - cmd == "none" || cmd == "no" || cmd == "disable") + cmd == "none" || cmd == "no" || cmd == "disable") option_t<report_t>::off(); else option_t<report_t>::on_with(whence, text); @@ -738,9 +738,9 @@ public: OPTION_(report_t, percent, DO() { // -% parent->HANDLER(total_) - .set_expr(string("--percent"), - "((is_account&parent&parent.total)?" - " percent(scrub(total), scrub(parent.total)):0"); + .set_expr(string("--percent"), + "((is_account&parent&parent.total)?" + " percent(scrub(total), scrub(parent.total)):0"); }); OPTION__ @@ -751,19 +751,19 @@ public: option_t<report_t>::on_with(whence, text); else option_t<report_t>::on_with(whence, - string_value(text.as_string() + " " + str())); + string_value(text.as_string() + " " + str())); }); OPTION(report_t, pivot_); OPTION__(report_t, plot_amount_format_, CTOR(report_t, plot_amount_format_) { on(none, - "%(format_date(date, \"%Y-%m-%d\")) %(quantity(scrub(display_amount)))\n"); + "%(format_date(date, \"%Y-%m-%d\")) %(quantity(scrub(display_amount)))\n"); }); OPTION__(report_t, plot_total_format_, CTOR(report_t, plot_total_format_) { on(none, - "%(format_date(date, \"%Y-%m-%d\")) %(quantity(scrub(display_total)))\n"); + "%(format_date(date, \"%Y-%m-%d\")) %(quantity(scrub(display_total)))\n"); }); OPTION(report_t, prepend_format_); @@ -773,20 +773,20 @@ public: OPTION_(report_t, price, DO() { // -I parent->HANDLER(display_amount_) - .set_expr(string("--price"), "price(amount_expr)"); + .set_expr(string("--price"), "price(amount_expr)"); parent->HANDLER(display_total_) - .set_expr(string("--price"), "price(total_expr)"); + .set_expr(string("--price"), "price(total_expr)"); }); OPTION__(report_t, prices_format_, CTOR(report_t, prices_format_) { on(none, - "%(date) %-8(display_account) %(justify(scrub(display_amount), 12, " - " 2 + 9 + 8 + 12, true, color))\n"); + "%(date) %-8(display_account) %(justify(scrub(display_amount), 12, " + " 2 + 9 + 8 + 12, true, color))\n"); }); OPTION__(report_t, pricedb_format_, CTOR(report_t, pricedb_format_) { on(none, - "P %(datetime) %(display_account) %(scrub(display_amount))\n"); + "P %(datetime) %(display_account) %(scrub(display_amount))\n"); }); OPTION_(report_t, quantity, DO() { // -O @@ -807,20 +807,20 @@ public: OPTION__(report_t, register_format_, CTOR(report_t, register_format_) { on(none, - "%(ansify_if(justify(format_date(date), date_width), green " - " if color & date > today))" - " %(ansify_if(justify(truncated(payee, payee_width), payee_width), " - " bold if color & !cleared & actual))" - " %(ansify_if(justify(truncated(display_account, account_width, " - " abbrev_len), account_width), blue if color))" - " %(justify(scrub(display_amount), amount_width, " - " 3 + meta_width + date_width + payee_width + account_width" - " + amount_width + prepend_width, true, color))" - " %(justify(scrub(display_total), total_width, " - " 4 + meta_width + date_width + payee_width + account_width" - " + amount_width + total_width + prepend_width, true, color))\n%/" - "%(justify(\" \", 2 + date_width + payee_width))" - "%$3 %$4 %$5\n"); + "%(ansify_if(justify(format_date(date), date_width), green " + " if color & date > today))" + " %(ansify_if(justify(truncated(payee, payee_width), payee_width), " + " bold if color & !cleared & actual))" + " %(ansify_if(justify(truncated(display_account, account_width, " + " abbrev_len), account_width), blue if color))" + " %(justify(scrub(display_amount), amount_width, " + " 3 + meta_width + date_width + payee_width + account_width" + " + amount_width + prepend_width, true, color))" + " %(justify(scrub(display_total), total_width, " + " 4 + meta_width + date_width + payee_width + account_width" + " + amount_width + total_width + prepend_width, true, color))\n%/" + "%(justify(\" \", 2 + date_width + payee_width))" + "%$3 %$4 %$5\n"); }); OPTION(report_t, related); // -r @@ -885,14 +885,14 @@ public: OPTION_(report_t, truncate_, DO_(args) { string style(args[1].to_string()); if (style == "leading") - format_t::default_style = format_t::TRUNCATE_LEADING; + format_t::default_style = format_t::TRUNCATE_LEADING; else if (style == "middle") - format_t::default_style = format_t::TRUNCATE_MIDDLE; + format_t::default_style = format_t::TRUNCATE_MIDDLE; else if (style == "trailing") - format_t::default_style = format_t::TRUNCATE_TRAILING; + format_t::default_style = format_t::TRUNCATE_TRAILING; else - throw_(std::invalid_argument, - _("Unrecognized truncation style: '%1'") << style); + throw_(std::invalid_argument, + _("Unrecognized truncation style: '%1'") << style); format_t::default_style_changed = true; }); @@ -911,9 +911,9 @@ public: OPTION_(report_t, unround, DO() { parent->HANDLER(display_amount_) - .set_expr(string("--unround"), "unrounded(amount_expr)"); + .set_expr(string("--unround"), "unrounded(amount_expr)"); parent->HANDLER(display_total_) - .set_expr(string("--unround"), "unrounded(total_expr)"); + .set_expr(string("--unround"), "unrounded(total_expr)"); }); OPTION(report_t, unsorted); @@ -931,36 +931,36 @@ public: }); OPTION__(report_t, meta_width_, - bool specified; - CTOR(report_t, meta_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, meta_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); OPTION__(report_t, date_width_, - bool specified; - CTOR(report_t, date_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, date_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); OPTION__(report_t, payee_width_, - bool specified; - CTOR(report_t, payee_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, payee_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); OPTION__(report_t, account_width_, - bool specified; - CTOR(report_t, account_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, account_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); OPTION__(report_t, amount_width_, - bool specified; - CTOR(report_t, amount_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, amount_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); OPTION__(report_t, total_width_, - bool specified; - CTOR(report_t, total_width_) { specified = false; } - DO_(args) { value = args[1].to_long(); specified = true; }); + bool specified; + CTOR(report_t, total_width_) { specified = false; } + DO_(args) { value = args[1].to_long(); specified = true; }); }; template <class Type = post_t, - class handler_ptr = post_handler_ptr, - void (report_t::*report_method)(handler_ptr) = - &report_t::posts_report> + class handler_ptr = post_handler_ptr, + void (report_t::*report_method)(handler_ptr) = + &report_t::posts_report> class reporter { shared_ptr<item_handler<Type> > handler; @@ -970,7 +970,7 @@ class reporter public: reporter(item_handler<Type> * _handler, - report_t& _report, const string& _whence) + report_t& _report, const string& _whence) : handler(_handler), report(_report), whence(_whence) {} value_t operator()(call_scope_t& args) diff --git a/src/scope.cc b/src/scope.cc index 72cf4ad3..faad352a 100644 --- a/src/scope.cc +++ b/src/scope.cc @@ -38,7 +38,7 @@ namespace ledger { scope_t * scope_t::default_scope = NULL; void symbol_scope_t::define(const symbol_t::kind_t kind, - const string& name, expr_t::ptr_op_t def) + const string& name, expr_t::ptr_op_t def) { DEBUG("scope.symbols", "Defining '" << name << "' = " << def); @@ -53,15 +53,15 @@ void symbol_scope_t::define(const symbol_t::kind_t kind, symbols->erase(i); result = symbols->insert(symbol_map::value_type(symbol_t(kind, name, def), - def)); + def)); if (! result.second) throw_(compile_error, - _("Redefinition of '%1' in the same scope") << name); + _("Redefinition of '%1' in the same scope") << name); } } expr_t::ptr_op_t symbol_scope_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (symbols) { symbol_map::const_iterator i = symbols->find(symbol_t(kind, name)); diff --git a/src/scope.h b/src/scope.h index 1e6f24a1..e3dd3e3f 100644 --- a/src/scope.h +++ b/src/scope.h @@ -58,8 +58,8 @@ struct symbol_t FORMAT }; - kind_t kind; - string name; + kind_t kind; + string name; expr_t::ptr_op_t definition; symbol_t() : kind(UNKNOWN), name(""), definition(NULL) { @@ -110,9 +110,9 @@ public: } virtual void define(const symbol_t::kind_t, const string&, - expr_t::ptr_op_t) {} + expr_t::ptr_op_t) {} virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name) = 0; + const string& name) = 0; #if defined(HAVE_BOOST_SERIALIZATION) private: @@ -142,13 +142,13 @@ public: } virtual void define(const symbol_t::kind_t kind, - const string& name, expr_t::ptr_op_t def) { + const string& name, expr_t::ptr_op_t def) { if (parent) parent->define(kind, name, def); } virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name) { + const string& name) { if (parent) return parent->lookup(kind, name); return NULL; @@ -186,10 +186,10 @@ public: } virtual void define(const symbol_t::kind_t kind, const string& name, - expr_t::ptr_op_t def); + expr_t::ptr_op_t def); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); #if defined(HAVE_BOOST_SERIALIZATION) private: @@ -292,7 +292,7 @@ public: scope_t& grandchild; explicit bind_scope_t(scope_t& _parent, - scope_t& _grandchild) + scope_t& _grandchild) : child_scope_t(_parent), grandchild(_grandchild) { TRACE_CTOR(bind_scope_t, "scope_t&, scope_t&"); } @@ -301,13 +301,13 @@ public: } virtual void define(const symbol_t::kind_t kind, const string& name, - expr_t::ptr_op_t def) { + expr_t::ptr_op_t def) { parent->define(kind, name, def); grandchild.define(kind, name, def); } virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name) { + const string& name) { if (expr_t::ptr_op_t def = grandchild.lookup(kind, name)) return def; return child_scope_t::lookup(kind, name); @@ -366,7 +366,7 @@ public: value_scope_t(const value_t& _value) : value(_value) {} virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (kind != symbol_t::FUNCTION) return NULL; diff --git a/src/session.cc b/src/session.cc index f8befde4..8adfef38 100644 --- a/src/session.cc +++ b/src/session.cc @@ -105,37 +105,37 @@ std::size_t session_t::read_data(const string& master_account) cache = archive_t(HANDLED(cache_).str()); if (! (cache && - cache->should_load(HANDLER(file_).data_files) && - cache->load(*journal.get()))) { + cache->should_load(HANDLER(file_).data_files) && + cache->load(*journal.get()))) { #endif // HAVE_BOOST_SERIALIZATION if (price_db_path) { if (exists(*price_db_path)) { - if (journal->read(*price_db_path) > 0) - throw_(parse_error, _("Transactions not allowed in price history file")); + if (journal->read(*price_db_path) > 0) + throw_(parse_error, _("Transactions not allowed in price history file")); } } foreach (const path& pathname, HANDLER(file_).data_files) { if (pathname == "-") { - // To avoid problems with stdin and pipes, etc., we read the entire - // file in beforehand into a memory buffer, and then parcel it out - // from there. - std::ostringstream buffer; - - while (std::cin.good() && ! std::cin.eof()) { - char line[8192]; - std::cin.read(line, 8192); - std::streamsize count = std::cin.gcount(); - buffer.write(line, count); - } - buffer.flush(); - - std::istringstream buf_in(buffer.str()); - - xact_count += journal->read(buf_in, "/dev/stdin", acct); - journal->sources.push_back(journal_t::fileinfo_t()); + // To avoid problems with stdin and pipes, etc., we read the entire + // file in beforehand into a memory buffer, and then parcel it out + // from there. + std::ostringstream buffer; + + while (std::cin.good() && ! std::cin.eof()) { + char line[8192]; + std::cin.read(line, 8192); + std::streamsize count = std::cin.gcount(); + buffer.write(line, count); + } + buffer.flush(); + + std::istringstream buf_in(buffer.str()); + + xact_count += journal->read(buf_in, "/dev/stdin", acct); + journal->sources.push_back(journal_t::fileinfo_t()); } else { - xact_count += journal->read(pathname, acct); + xact_count += journal->read(pathname, acct); } } @@ -166,7 +166,7 @@ void session_t::read_journal_files() std::size_t count = read_data(master_account); if (count == 0) throw_(parse_error, - _("Failed to locate any transactions; did you specify a valid file with -f?")); + _("Failed to locate any transactions; did you specify a valid file with -f?")); INFO_FINISH(journal); @@ -222,7 +222,7 @@ option_t<session_t> * session_t::lookup_option(const char * p) } expr_t::ptr_op_t session_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { switch (kind) { case symbol_t::FUNCTION: diff --git a/src/session.h b/src/session.h index 3916b964..4968f1b8 100644 --- a/src/session.h +++ b/src/session.h @@ -57,8 +57,8 @@ class session_t : public symbol_scope_t friend void set_session_context(session_t * session); public: - bool flush_on_next_data_file; - date_t::year_type current_year; + bool flush_on_next_data_file; + date_t::year_type current_year; std::auto_ptr<journal_t> journal; explicit session_t(); @@ -91,7 +91,7 @@ public: option_t<session_t> * lookup_option(const char * p); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); /** * Option handlers diff --git a/src/stats.cc b/src/stats.cc index 86a8338d..172971aa 100644 --- a/src/stats.cc +++ b/src/stats.cc @@ -58,11 +58,11 @@ value_t report_statistics(call_scope_t& args) { straccstream accum; out << ACCUM(accum << _("Time period: %1 to %2 (%3 days)") - << format_date(statistics.earliest_post) - << format_date(statistics.latest_post) - << (statistics.latest_post - - statistics.earliest_post).days()) - << std::endl << std::endl; + << format_date(statistics.earliest_post) + << format_date(statistics.latest_post) + << (statistics.latest_post - + statistics.earliest_post).days()) + << std::endl << std::endl; } out << _(" Files these postings came from:") << std::endl; @@ -89,12 +89,12 @@ value_t report_statistics(call_scope_t& args) out << " ("; out.precision(2); out << (double((statistics.latest_post - statistics.earliest_post).days()) / - double(statistics.posts_count)) << _(" per day)") << std::endl; + double(statistics.posts_count)) << _(" per day)") << std::endl; out << _(" Uncleared postings: "); out.width(6); out << (statistics.posts_count - - statistics.posts_cleared_count) << std::endl; + statistics.posts_cleared_count) << std::endl; out << std::endl; diff --git a/src/stream.cc b/src/stream.cc index 272d4f1c..79faa05a 100644 --- a/src/stream.cc +++ b/src/stream.cc @@ -73,11 +73,11 @@ namespace { if (status < 0) { throw std::logic_error(_("Failed to fork child process")); } - else if (status == 0) { // child + else if (status == 0) { // child // Duplicate pipe's reading end into stdin status = dup2(pfd[0], STDIN_FILENO); if (status == -1) - perror("dup2"); + perror("dup2"); // Close unuseful file descriptors: the pipe's writing and reading // ends (the latter is not needed anymore, after the duplication). @@ -98,7 +98,7 @@ namespace { perror((std::string("execlp: ") + pager_path.string()).c_str()); exit(1); } - else { // parent + else { // parent close(pfd[0]); typedef iostreams::stream<iostreams::file_descriptor_sink> fdstream; *os = new fdstream(pfd[1]); @@ -108,7 +108,7 @@ namespace { } void output_stream_t::initialize(const optional<path>& output_file, - const optional<path>& pager_path) + const optional<path>& pager_path) { if (output_file && *output_file != "-") os = new ofstream(*output_file); diff --git a/src/stream.h b/src/stream.h index 356df08c..42c85534 100644 --- a/src/stream.h +++ b/src/stream.h @@ -114,7 +114,7 @@ public: * empty. */ void initialize(const optional<path>& output_file = none, - const optional<path>& pager_path = none); + const optional<path>& pager_path = none); /** * Convertor to a standard ostream. This is used so that we can diff --git a/src/temps.cc b/src/temps.cc index 7a630176..365c33c5 100644 --- a/src/temps.cc +++ b/src/temps.cc @@ -63,7 +63,7 @@ xact_t& temporaries_t::create_xact() } post_t& temporaries_t::copy_post(post_t& origin, xact_t& xact, - account_t * account) + account_t * account) { if (! post_temps) post_temps = std::list<post_t>(); @@ -99,7 +99,7 @@ post_t& temporaries_t::create_post(xact_t& xact, account_t * account) } account_t& temporaries_t::create_account(const string& name, - account_t * parent) + account_t * parent) { if (! acct_temps) acct_temps = std::list<account_t>(); @@ -119,10 +119,10 @@ void temporaries_t::clear() if (post_temps) { foreach (post_t& post, *post_temps) { if (! post.xact->has_flags(ITEM_TEMP)) - post.xact->remove_post(&post); + post.xact->remove_post(&post); if (post.account && ! post.account->has_flags(ACCOUNT_TEMP)) - post.account->remove_post(&post); + post.account->remove_post(&post); } post_temps->clear(); } @@ -133,7 +133,7 @@ void temporaries_t::clear() if (acct_temps) { foreach (account_t& acct, *acct_temps) { if (acct.parent && ! acct.parent->has_flags(ACCOUNT_TEMP)) - acct.parent->remove_account(&acct); + acct.parent->remove_account(&acct); } acct_temps->clear(); } diff --git a/src/temps.h b/src/temps.h index 210bbf63..1e7eb69f 100644 --- a/src/temps.h +++ b/src/temps.h @@ -61,13 +61,13 @@ public: return xact_temps->back(); } post_t& copy_post(post_t& origin, xact_t& xact, - account_t * account = NULL); + account_t * account = NULL); post_t& create_post(xact_t& xact, account_t * account); post_t& last_post() { return post_temps->back(); } account_t& create_account(const string& name = "", - account_t * parent = NULL); + account_t * parent = NULL); account_t& last_account() { return acct_temps->back(); } diff --git a/src/textual.cc b/src/textual.cc index dba31323..5308fa18 100644 --- a/src/textual.cc +++ b/src/textual.cc @@ -49,26 +49,26 @@ namespace ledger { namespace { - typedef std::pair<commodity_t *, amount_t> fixed_rate_t; + typedef std::pair<commodity_t *, amount_t> fixed_rate_t; typedef variant<account_t *, string, fixed_rate_t> state_t; class parse_context_t : public noncopyable { public: - journal_t& journal; - scope_t& scope; + journal_t& journal; + scope_t& scope; std::list<state_t> state_stack; #if defined(TIMELOG_SUPPORT) - time_log_t timelog; + time_log_t timelog; #endif - bool strict; - std::size_t count; - std::size_t errors; - std::size_t sequence; + bool strict; + std::size_t count; + std::size_t errors; + std::size_t sequence; parse_context_t(journal_t& _journal, scope_t& _scope) : journal(_journal), scope(_scope), timelog(journal), - strict(false), count(0), errors(0), sequence(1) {} + strict(false), count(0), errors(0), sequence(1) {} bool front_is_account() { return state_stack.front().type() == typeid(account_t *); @@ -82,8 +82,8 @@ namespace { account_t * top_account() { foreach (state_t& state, state_stack) - if (state.type() == typeid(account_t *)) - return boost::get<account_t *>(state); + if (state.type() == typeid(account_t *)) + return boost::get<account_t *>(state); return NULL; } }; @@ -97,9 +97,9 @@ namespace { instance_t * parent; accounts_map account_aliases; const path * original_file; - path pathname; + path pathname; std::istream& in; - char linebuf[MAX_LINE + 1]; + char linebuf[MAX_LINE + 1]; std::size_t linenum; istream_pos_type line_beg_pos; istream_pos_type curr_pos; @@ -107,9 +107,9 @@ namespace { optional<date_t::year_type> current_year; instance_t(parse_context_t& _context, - std::istream& _in, - const path * _original_file = NULL, - instance_t * _parent = NULL); + std::istream& _in, + const path * _original_file = NULL, + instance_t * _parent = NULL); ~instance_t(); @@ -117,7 +117,7 @@ namespace { std::streamsize read_line(char *& line); bool peek_whitespace_line() { return (in.good() && ! in.eof() && - (in.peek() == ' ' || in.peek() == '\t')); + (in.peek() == ' ' || in.peek() == '\t')); } void read_next_directive(); @@ -148,31 +148,31 @@ namespace { void define_directive(char * line); bool general_directive(char * line); - post_t * parse_post(char * line, - std::streamsize len, - account_t * account, - xact_t * xact, - bool defer_expr = false); + post_t * parse_post(char * line, + std::streamsize len, + account_t * account, + xact_t * xact, + bool defer_expr = false); bool parse_posts(account_t * account, - xact_base_t& xact, - const bool defer_expr = false); + xact_base_t& xact, + const bool defer_expr = false); - xact_t * parse_xact(char * line, - std::streamsize len, - account_t * account); + xact_t * parse_xact(char * line, + std::streamsize len, + account_t * account); virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); }; - void parse_amount_expr(std::istream& in, - scope_t& scope, - post_t& post, - amount_t& amount, - const parse_flags_t& flags = PARSE_DEFAULT, - const bool defer_expr = false, - optional<expr_t> * amount_expr = NULL) + void parse_amount_expr(std::istream& in, + scope_t& scope, + post_t& post, + amount_t& amount, + const parse_flags_t& flags = PARSE_DEFAULT, + const bool defer_expr = false, + optional<expr_t> * amount_expr = NULL) { expr_t expr(in, flags.plus_flags(PARSE_PARTIAL)); @@ -181,25 +181,25 @@ namespace { #if defined(DEBUG_ENABLED) DEBUG_IF("textual.parse") { if (_debug_stream) { - ledger::dump_value_expr(*_debug_stream, expr); - *_debug_stream << std::endl; + ledger::dump_value_expr(*_debug_stream, expr); + *_debug_stream << std::endl; } } #endif if (expr) { if (amount_expr) - *amount_expr = expr; + *amount_expr = expr; if (! defer_expr) - amount = post.resolve_expr(scope, expr); + amount = post.resolve_expr(scope, expr); } } } instance_t::instance_t(parse_context_t& _context, - std::istream& _in, - const path * _original_file, - instance_t * _parent) + std::istream& _in, + const path * _original_file, + instance_t * _parent) : context(_context), parent(_parent), original_file(_original_file), pathname(original_file ? *original_file : "/dev/stdin"), in(_in) { @@ -216,7 +216,7 @@ void instance_t::parse() INFO("Parsing file '" << pathname.string() << "'"); TRACE_START(instance_parse, 1, - "Done parsing file '" << pathname.string() << "'"); + "Done parsing file '" << pathname.string() << "'"); if (! in.good() || in.eof()) return; @@ -232,30 +232,30 @@ void instance_t::parse() string current_context = error_context(); if (parent) { - std::list<instance_t *> instances; + std::list<instance_t *> instances; - for (instance_t * instance = parent; - instance; - instance = instance->parent) - instances.push_front(instance); + for (instance_t * instance = parent; + instance; + instance = instance->parent) + instances.push_front(instance); - foreach (instance_t * instance, instances) - add_error_context(_("In file included from %1") - << file_context(instance->pathname, - instance->linenum)); + foreach (instance_t * instance, instances) + add_error_context(_("In file included from %1") + << file_context(instance->pathname, + instance->linenum)); } add_error_context(_("While parsing file %1") - << file_context(pathname, linenum)); + << file_context(pathname, linenum)); if (caught_signal != NONE_CAUGHT) - throw; + throw; string err_context = error_context(); if (! err_context.empty()) - std::cerr << err_context << std::endl; + std::cerr << err_context << std::endl; if (! current_context.empty()) - std::cerr << current_context << std::endl; + std::cerr << current_context << std::endl; std::cerr << _("Error: ") << err.what() << std::endl; context.errors++; @@ -268,7 +268,7 @@ void instance_t::parse() std::streamsize instance_t::read_line(char *& line) { assert(in.good()); - assert(! in.eof()); // no one should call us in that case + assert(! in.eof()); // no one should call us in that case line_beg_pos = curr_pos; @@ -283,7 +283,7 @@ std::streamsize instance_t::read_line(char *& line) else line = linebuf; - if (line[len - 1] == '\r') // strip Windows CRLF down to LF + if (line[len - 1] == '\r') // strip Windows CRLF down to LF line[--len] = '\0'; linenum++; @@ -291,7 +291,7 @@ std::streamsize instance_t::read_line(char *& line) curr_pos = line_beg_pos; curr_pos += len; - return len - 1; // LF is being silently dropped + return len - 1; // LF is being silently dropped } return 0; } @@ -306,7 +306,7 @@ void instance_t::read_next_directive() switch (line[0]) { case '\0': - assert(false); // shouldn't ever reach here + assert(false); // shouldn't ever reach here break; case ' ': @@ -314,13 +314,13 @@ void instance_t::read_next_directive() break; } - case ';': // comments + case ';': // comments case '#': case '*': case '|': break; - case '-': // option setting + case '-': // option setting option_directive(line); break; @@ -336,10 +336,10 @@ void instance_t::read_next_directive() case '9': xact_directive(line, len); break; - case '=': // automated xact + case '=': // automated xact automated_xact_directive(line); break; - case '~': // period xact + case '~': // period xact period_xact_directive(line); break; @@ -347,47 +347,47 @@ void instance_t::read_next_directive() case '!': line++; // fall through... - default: // some other directive + default: // some other directive if (! general_directive(line)) { switch (line[0]) { #if defined(TIMELOG_SUPPORT) case 'i': - clock_in_directive(line, false); - break; + clock_in_directive(line, false); + break; case 'I': - clock_in_directive(line, true); - break; + clock_in_directive(line, true); + break; case 'o': - clock_out_directive(line, false); - break; + clock_out_directive(line, false); + break; case 'O': - clock_out_directive(line, true); - break; + clock_out_directive(line, true); + break; case 'h': case 'b': - break; + break; #endif // TIMELOG_SUPPORT - case 'A': // a default account for unbalanced posts - default_account_directive(line); - break; - case 'C': // a set of conversions - price_conversion_directive(line); - break; - case 'D': // a default commodity for "xact" - default_commodity_directive(line); - break; - case 'N': // don't download prices - nomarket_directive(line); - break; - case 'P': // a pricing xact - price_xact_directive(line); - break; - case 'Y': // set the current year - year_directive(line); - break; + case 'A': // a default account for unbalanced posts + default_account_directive(line); + break; + case 'C': // a set of conversions + price_conversion_directive(line); + break; + case 'D': // a default commodity for "xact" + default_commodity_directive(line); + break; + case 'N': // don't download prices + nomarket_directive(line); + break; + case 'P': // a pricing xact + price_xact_directive(line); + break; + case 'Y': // set the current year + year_directive(line); + break; } } break; @@ -418,9 +418,9 @@ void instance_t::clock_in_directive(char * line, bool /*capitalized*/) position.sequence = context.sequence++; time_xact_t event(position, parse_datetime(datetime, current_year), - p ? context.top_account()->find_account(p) : NULL, - n ? n : "", - end ? end : ""); + p ? context.top_account()->find_account(p) : NULL, + n ? n : "", + end ? end : ""); context.timelog.clock_in(event); } @@ -447,9 +447,9 @@ void instance_t::clock_out_directive(char * line, bool /*capitalized*/) position.sequence = context.sequence++; time_xact_t event(position, parse_datetime(datetime, current_year), - p ? context.top_account()->find_account(p) : NULL, - n ? n : "", - end ? end : ""); + p ? context.top_account()->find_account(p) : NULL, + n ? n : "", + end ? end : ""); context.timelog.clock_out(event); context.count++; @@ -526,8 +526,8 @@ void instance_t::automated_xact_directive(char * line) std::auto_ptr<auto_xact_t> ae (new auto_xact_t(query_t(string(skip_ws(line + 1)), - keep_details_t(true, true, true), false))); - ae->pos = position_t(); + keep_details_t(true, true, true), false))); + ae->pos = position_t(); ae->pos->pathname = pathname; ae->pos->beg_pos = line_beg_pos; ae->pos->beg_line = linenum; @@ -540,7 +540,7 @@ void instance_t::automated_xact_directive(char * line) context.journal.auto_xacts.push_back(ae.get()); - ae->journal = &context.journal; + ae->journal = &context.journal; ae->pos->end_pos = curr_pos; ae->pos->end_line = linenum; @@ -610,7 +610,7 @@ void instance_t::xact_directive(char * line, std::streamsize len) std::auto_ptr<xact_t> manager(xact); if (context.journal.add_xact(xact)) { - manager.release(); // it's owned by the journal now + manager.release(); // it's owned by the journal now context.count++; } // It's perfectly valid for the journal to reject the xact, which it will @@ -650,10 +650,10 @@ void instance_t::include_directive(char * line) mask_t glob; #if BOOST_VERSION >= 103700 - path parent_path = filename.parent_path(); + path parent_path = filename.parent_path(); glob.assign_glob(filename.filename()); #else // BOOST_VERSION >= 103700 - path parent_path = filename.branch_path(); + path parent_path = filename.branch_path(); glob.assign_glob(filename.leaf()); #endif // BOOST_VERSION >= 103700 @@ -661,33 +661,33 @@ void instance_t::include_directive(char * line) if (exists(parent_path)) { filesystem::directory_iterator end; for (filesystem::directory_iterator iter(parent_path); - iter != end; - ++iter) { + iter != end; + ++iter) { #if BOOST_VERSION <= 103500 if (is_regular(*iter)) #else if (is_regular_file(*iter)) #endif - { + { #if BOOST_VERSION >= 103700 - string base = (*iter).filename(); + string base = (*iter).filename(); #else // BOOST_VERSION >= 103700 - string base = (*iter).leaf(); + string base = (*iter).leaf(); #endif // BOOST_VERSION >= 103700 - if (glob.match(base)) { - path inner_file(*iter); - ifstream stream(inner_file); - instance_t instance(context, stream, &inner_file, this); - instance.parse(); - files_found = true; - } + if (glob.match(base)) { + path inner_file(*iter); + ifstream stream(inner_file); + instance_t instance(context, stream, &inner_file, this); + instance.parse(); + files_found = true; + } } } } if (! files_found) throw_(std::runtime_error, - _("File to include was not found: '%1'") << filename); + _("File to include was not found: '%1'") << filename); } @@ -707,17 +707,17 @@ void instance_t::end_directive(char * kind) if ((name.empty() || name == "account") && ! context.front_is_account()) throw_(std::runtime_error, - _("'end account' directive does not match open directive")); + _("'end account' directive does not match open directive")); else if (name == "tag" && ! context.front_is_string()) throw_(std::runtime_error, - _("'end tag' directive does not match open directive")); + _("'end tag' directive does not match open directive")); else if (name == "fixed" && ! context.front_is_fixed_rate()) throw_(std::runtime_error, - _("'end fixed' directive does not match open directive")); + _("'end fixed' directive does not match open directive")); if (context.state_stack.size() <= 1) throw_(std::runtime_error, - _("'end' found, but no enclosing tag or account directive")); + _("'end' found, but no enclosing tag or account directive")); else context.state_stack.pop_front(); } @@ -747,9 +747,9 @@ void instance_t::fixed_directive(char * line) { if (optional<std::pair<commodity_t *, price_point_t> > price_point = commodity_pool_t::current_pool->parse_price_directive(trim_ws(line), - true)) { + true)) { context.state_stack.push_front(fixed_rate_t(price_point->first, - price_point->second.price)); + price_point->second.price)); } else { throw_(std::runtime_error, _("Error in fixed directive")); } @@ -789,7 +789,7 @@ void instance_t::account_mapping_directive(char * line) if (payee_regex) context.journal.account_mappings.push_back (account_mapping_t(mask_t(payee_regex), - context.top_account()->find_account(account_name))); + context.top_account()->find_account(account_name))); while (peek_whitespace_line()) { #if defined(NO_ASSERTS) @@ -805,7 +805,7 @@ void instance_t::account_mapping_directive(char * line) context.journal.account_mappings.push_back (account_mapping_t(mask_t(payee_regex), - context.top_account()->find_account(account_name))); + context.top_account()->find_account(account_name))); } } @@ -822,7 +822,7 @@ void instance_t::tag_directive(char * line) void instance_t::define_directive(char * line) { expr_t def(skip_ws(line)); - def.compile(context.scope); // causes definitions to be established + def.compile(context.scope); // causes definitions to be established } bool instance_t::general_directive(char * line) @@ -923,18 +923,18 @@ bool instance_t::general_directive(char * line) return false; } -post_t * instance_t::parse_post(char * line, - std::streamsize len, - account_t * account, - xact_t * xact, - bool defer_expr) +post_t * instance_t::parse_post(char * line, + std::streamsize len, + account_t * account, + xact_t * xact, + bool defer_expr) { TRACE_START(post_details, 1, "Time spent parsing postings:"); std::auto_ptr<post_t> post(new post_t); - post->xact = xact; // this could be NULL - post->pos = position_t(); + post->xact = xact; // this could be NULL + post->pos = position_t(); post->pos->pathname = pathname; post->pos->beg_pos = line_beg_pos; post->pos->beg_line = linenum; @@ -958,14 +958,14 @@ post_t * instance_t::parse_post(char * line, post->set_state(item_t::CLEARED); p = skip_ws(p + 1); DEBUG("textual.parse", "line " << linenum << ": " - << "Parsed the CLEARED flag"); + << "Parsed the CLEARED flag"); break; case '!': post->set_state(item_t::PENDING); p = skip_ws(p + 1); DEBUG("textual.parse", "line " << linenum << ": " - << "Parsed the PENDING flag"); + << "Parsed the PENDING flag"); break; } @@ -988,19 +988,19 @@ post_t * instance_t::parse_post(char * line, if ((*p == '[' && *(e - 1) == ']') || (*p == '(' && *(e - 1) == ')')) { post->add_flags(POST_VIRTUAL); DEBUG("textual.parse", "line " << linenum << ": " - << "Parsed a virtual account name"); + << "Parsed a virtual account name"); if (*p == '[') { post->add_flags(POST_MUST_BALANCE); DEBUG("textual.parse", "line " << linenum << ": " - << "Posting must balance"); + << "Posting must balance"); } p++; e--; } string name(p, e - p); DEBUG("textual.parse", "line " << linenum << ": " - << "Parsed account name " << name); + << "Parsed account name " << name); if (account_aliases.size() > 0) { accounts_map::const_iterator i = account_aliases.find(name); @@ -1013,15 +1013,15 @@ post_t * instance_t::parse_post(char * line, if (context.strict && ! post->account->has_flags(ACCOUNT_KNOWN)) { if (post->_state == item_t::UNCLEARED) warning_(_("\"%1\", line %2: Unknown account '%3'") - << pathname << linenum << post->account->fullname()); + << pathname << linenum << post->account->fullname()); post->account->add_flags(ACCOUNT_KNOWN); } if (post->account->name == _("Unknown")) { foreach (account_mapping_t& value, context.journal.account_mappings) { if (value.first.match(xact->payee)) { - post->account = value.second; - break; + post->account = value.second; + break; } } } @@ -1036,39 +1036,39 @@ post_t * instance_t::parse_post(char * line, beg = next - line; ptristream stream(next, len - beg); - if (*next != '(') // indicates a value expression + if (*next != '(') // indicates a value expression post->amount.parse(stream, PARSE_NO_REDUCE); else parse_amount_expr(stream, context.scope, *post.get(), post->amount, - PARSE_NO_REDUCE | PARSE_SINGLE | PARSE_NO_ASSIGN, - defer_expr, &post->amount_expr); + PARSE_NO_REDUCE | PARSE_SINGLE | PARSE_NO_ASSIGN, + defer_expr, &post->amount_expr); if (! post->amount.is_null() && post->amount.has_commodity()) { if (context.strict && - ! post->amount.commodity().has_flags(COMMODITY_KNOWN)) { - if (post->_state == item_t::UNCLEARED) - warning_(_("\"%1\", line %2: Unknown commodity '%3'") - << pathname << linenum << post->amount.commodity()); - post->amount.commodity().add_flags(COMMODITY_KNOWN); + ! post->amount.commodity().has_flags(COMMODITY_KNOWN)) { + if (post->_state == item_t::UNCLEARED) + warning_(_("\"%1\", line %2: Unknown commodity '%3'") + << pathname << linenum << post->amount.commodity()); + post->amount.commodity().add_flags(COMMODITY_KNOWN); } if (! post->amount.has_annotation()) { - foreach (state_t& state, context.state_stack) { - if (state.type() == typeid(fixed_rate_t)) { - fixed_rate_t& rate(boost::get<fixed_rate_t>(state)); - if (*rate.first == post->amount.commodity()) { - annotation_t details(rate.second); - details.add_flags(ANNOTATION_PRICE_FIXATED); - post->amount.annotate(details); - break; - } - } - } + foreach (state_t& state, context.state_stack) { + if (state.type() == typeid(fixed_rate_t)) { + fixed_rate_t& rate(boost::get<fixed_rate_t>(state)); + if (*rate.first == post->amount.commodity()) { + annotation_t details(rate.second); + details.add_flags(ANNOTATION_PRICE_FIXATED); + post->amount.annotate(details); + break; + } + } + } } } DEBUG("textual.parse", "line " << linenum << ": " - << "post amount = " << post->amount); + << "post amount = " << post->amount); if (stream.eof()) { next = NULL; @@ -1078,73 +1078,73 @@ post_t * instance_t::parse_post(char * line, // Parse the optional cost (@ PER-UNIT-COST, @@ TOTAL-COST) if (*next == '@') { - DEBUG("textual.parse", "line " << linenum << ": " - << "Found a price indicator"); - - bool per_unit = true; - - if (*++next == '@') { - per_unit = false; - post->add_flags(POST_COST_IN_FULL); - DEBUG("textual.parse", "line " << linenum << ": " - << "And it's for a total price"); - } - - beg = ++next - line; - - p = skip_ws(next); - if (*p) { - post->cost = amount_t(); - - bool fixed_cost = false; - if (*p == '=') { - p++; - fixed_cost = true; - if (*p == '\0') - throw parse_error(_("Posting is missing a cost amount")); - } - - beg = p - line; - ptristream cstream(p, len - beg); - - if (*p != '(') // indicates a value expression - post->cost->parse(cstream, PARSE_NO_MIGRATE); - else - parse_amount_expr(cstream, context.scope, *post.get(), *post->cost, - PARSE_NO_MIGRATE | PARSE_SINGLE | PARSE_NO_ASSIGN); - - if (post->cost->sign() < 0) - throw parse_error(_("A posting's cost may not be negative")); - - post->cost->in_place_unround(); - - if (per_unit) { - // For the sole case where the cost might be uncommoditized, - // guarantee that the commodity of the cost after multiplication - // is the same as it was before. - commodity_t& cost_commodity(post->cost->commodity()); - *post->cost *= post->amount; - post->cost->set_commodity(cost_commodity); - } - else if (post->amount.sign() < 0) { - post->cost->in_place_negate(); - } - - if (fixed_cost) - post->add_flags(POST_COST_FIXATED); - - DEBUG("textual.parse", "line " << linenum << ": " - << "Total cost is " << *post->cost); - DEBUG("textual.parse", "line " << linenum << ": " - << "Annotated amount is " << post->amount); - - if (cstream.eof()) - next = NULL; - else - next = skip_ws(p + static_cast<std::ptrdiff_t>(cstream.tellg())); - } else { - throw parse_error(_("Expected a cost amount")); - } + DEBUG("textual.parse", "line " << linenum << ": " + << "Found a price indicator"); + + bool per_unit = true; + + if (*++next == '@') { + per_unit = false; + post->add_flags(POST_COST_IN_FULL); + DEBUG("textual.parse", "line " << linenum << ": " + << "And it's for a total price"); + } + + beg = ++next - line; + + p = skip_ws(next); + if (*p) { + post->cost = amount_t(); + + bool fixed_cost = false; + if (*p == '=') { + p++; + fixed_cost = true; + if (*p == '\0') + throw parse_error(_("Posting is missing a cost amount")); + } + + beg = p - line; + ptristream cstream(p, len - beg); + + if (*p != '(') // indicates a value expression + post->cost->parse(cstream, PARSE_NO_MIGRATE); + else + parse_amount_expr(cstream, context.scope, *post.get(), *post->cost, + PARSE_NO_MIGRATE | PARSE_SINGLE | PARSE_NO_ASSIGN); + + if (post->cost->sign() < 0) + throw parse_error(_("A posting's cost may not be negative")); + + post->cost->in_place_unround(); + + if (per_unit) { + // For the sole case where the cost might be uncommoditized, + // guarantee that the commodity of the cost after multiplication + // is the same as it was before. + commodity_t& cost_commodity(post->cost->commodity()); + *post->cost *= post->amount; + post->cost->set_commodity(cost_commodity); + } + else if (post->amount.sign() < 0) { + post->cost->in_place_negate(); + } + + if (fixed_cost) + post->add_flags(POST_COST_FIXATED); + + DEBUG("textual.parse", "line " << linenum << ": " + << "Total cost is " << *post->cost); + DEBUG("textual.parse", "line " << linenum << ": " + << "Annotated amount is " << post->amount); + + if (cstream.eof()) + next = NULL; + else + next = skip_ws(p + static_cast<std::ptrdiff_t>(cstream.tellg())); + } else { + throw parse_error(_("Expected a cost amount")); + } } } } @@ -1153,7 +1153,7 @@ post_t * instance_t::parse_post(char * line, if (xact && next && *next == '=') { DEBUG("textual.parse", "line " << linenum << ": " - << "Found a balance assignment indicator"); + << "Found a balance assignment indicator"); beg = ++next - line; @@ -1164,70 +1164,70 @@ post_t * instance_t::parse_post(char * line, beg = p - line; ptristream stream(p, len - beg); - if (*p != '(') // indicates a value expression - post->assigned_amount->parse(stream, PARSE_NO_MIGRATE); + if (*p != '(') // indicates a value expression + post->assigned_amount->parse(stream, PARSE_NO_MIGRATE); else - parse_amount_expr(stream, context.scope, *post.get(), - *post->assigned_amount, - PARSE_SINGLE | PARSE_NO_MIGRATE); + parse_amount_expr(stream, context.scope, *post.get(), + *post->assigned_amount, + PARSE_SINGLE | PARSE_NO_MIGRATE); if (post->assigned_amount->is_null()) { - if (post->amount.is_null()) - throw parse_error(_("Balance assignment must evaluate to a constant")); - else - throw parse_error(_("Balance assertion must evaluate to a constant")); + if (post->amount.is_null()) + throw parse_error(_("Balance assignment must evaluate to a constant")); + else + throw parse_error(_("Balance assertion must evaluate to a constant")); } DEBUG("textual.parse", "line " << linenum << ": " - << "POST assign: parsed amt = " << *post->assigned_amount); + << "POST assign: parsed amt = " << *post->assigned_amount); - amount_t& amt(*post->assigned_amount); + amount_t& amt(*post->assigned_amount); value_t account_total - (post->account->amount(false).strip_annotations(keep_details_t())); + (post->account->amount(false).strip_annotations(keep_details_t())); DEBUG("post.assign", - "line " << linenum << ": " "account balance = " << account_total); + "line " << linenum << ": " "account balance = " << account_total); DEBUG("post.assign", - "line " << linenum << ": " "post amount = " << amt); + "line " << linenum << ": " "post amount = " << amt); amount_t diff = amt; switch (account_total.type()) { case value_t::AMOUNT: - diff -= account_total.as_amount(); - break; + diff -= account_total.as_amount(); + break; case value_t::BALANCE: - if (optional<amount_t> comm_bal = - account_total.as_balance().commodity_amount(amt.commodity())) - diff -= *comm_bal; - break; + if (optional<amount_t> comm_bal = + account_total.as_balance().commodity_amount(amt.commodity())) + diff -= *comm_bal; + break; default: - break; + break; } DEBUG("post.assign", - "line " << linenum << ": " << "diff = " << diff); + "line " << linenum << ": " << "diff = " << diff); DEBUG("textual.parse", - "line " << linenum << ": " << "POST assign: diff = " << diff); + "line " << linenum << ": " << "POST assign: diff = " << diff); if (! diff.is_zero()) { - if (! post->amount.is_null()) { - diff -= post->amount; - if (! diff.is_zero()) - throw_(parse_error, _("Balance assertion off by %1") << diff); - } else { - post->amount = diff; - DEBUG("textual.parse", "line " << linenum << ": " - << "Overwrite null posting"); - } + if (! post->amount.is_null()) { + diff -= post->amount; + if (! diff.is_zero()) + throw_(parse_error, _("Balance assertion off by %1") << diff); + } else { + post->amount = diff; + DEBUG("textual.parse", "line " << linenum << ": " + << "Overwrite null posting"); + } } if (stream.eof()) - next = NULL; + next = NULL; else - next = skip_ws(p + static_cast<std::ptrdiff_t>(stream.tellg())); + next = skip_ws(p + static_cast<std::ptrdiff_t>(stream.tellg())); } else { throw parse_error(_("Expected an balance assignment/assertion amount")); } @@ -1239,15 +1239,15 @@ post_t * instance_t::parse_post(char * line, post->append_note(++next, true, current_year); next = line + len; DEBUG("textual.parse", "line " << linenum << ": " - << "Parsed a posting note"); + << "Parsed a posting note"); } // There should be nothing more to read if (next && *next) throw_(parse_error, - _("Unexpected char '%1' (Note: inline math requires parentheses)") - << *next); + _("Unexpected char '%1' (Note: inline math requires parentheses)") + << *next); post->pos->end_pos = curr_pos; post->pos->end_line = linenum; @@ -1255,7 +1255,7 @@ post_t * instance_t::parse_post(char * line, if (! context.state_stack.empty()) { foreach (const state_t& state, context.state_stack) if (state.type() == typeid(string)) - post->parse_tags(boost::get<string>(state).c_str(), true); + post->parse_tags(boost::get<string>(state).c_str(), true); } TRACE_STOP(post_details, 1); @@ -1271,8 +1271,8 @@ post_t * instance_t::parse_post(char * line, } bool instance_t::parse_posts(account_t * account, - xact_base_t& xact, - const bool defer_expr) + xact_base_t& xact, + const bool defer_expr) { TRACE_START(xact_posts, 1, "Time spent parsing postings:"); @@ -1294,15 +1294,15 @@ bool instance_t::parse_posts(account_t * account, return added; } -xact_t * instance_t::parse_xact(char * line, - std::streamsize len, - account_t * account) +xact_t * instance_t::parse_xact(char * line, + std::streamsize len, + account_t * account) { TRACE_START(xact_text, 1, "Time spent parsing transaction text:"); std::auto_ptr<xact_t> xact(new xact_t); - xact->pos = position_t(); + xact->pos = position_t(); xact->pos->pathname = pathname; xact->pos->beg_pos = line_beg_pos; xact->pos->beg_line = linenum; @@ -1353,8 +1353,8 @@ xact_t * instance_t::parse_xact(char * line, char * p = next_element(next, true); foreach (payee_mapping_t& value, context.journal.payee_mappings) { if (value.first.match(next)) { - xact->payee = value.second; - break; + xact->payee = value.second; + break; } } if (xact->payee.empty()) @@ -1387,9 +1387,9 @@ xact_t * instance_t::parse_xact(char * line, if (*p == ';') { item_t * item; if (last_post) - item = last_post; + item = last_post; else - item = xact.get(); + item = xact.get(); // This is a trailing note, and possibly a metadata info tag item->append_note(p + 1, true, current_year); @@ -1399,9 +1399,9 @@ xact_t * instance_t::parse_xact(char * line, reveal_context = false; if (post_t * post = - parse_post(p, len - (p - line), account, xact.get())) { - xact->add_post(post); - last_post = post; + parse_post(p, len - (p - line), account, xact.get())) { + xact->add_post(post); + last_post = post; } } } @@ -1411,11 +1411,11 @@ xact_t * instance_t::parse_xact(char * line, foreach (post_t * post, xact->posts) { if (post->_state == item_t::UNCLEARED) { - result = item_t::UNCLEARED; - break; + result = item_t::UNCLEARED; + break; } else if (post->_state == item_t::PENDING) { - result = item_t::PENDING; + result = item_t::PENDING; } } } @@ -1426,7 +1426,7 @@ xact_t * instance_t::parse_xact(char * line, if (! context.state_stack.empty()) { foreach (const state_t& state, context.state_stack) if (state.type() == typeid(string)) - xact->parse_tags(boost::get<string>(state).c_str(), false); + xact->parse_tags(boost::get<string>(state).c_str(), false); } TRACE_STOP(xact_details, 1); @@ -1438,23 +1438,23 @@ xact_t * instance_t::parse_xact(char * line, if (reveal_context) { add_error_context(_("While parsing transaction:")); add_error_context(source_context(xact->pos->pathname, - xact->pos->beg_pos, curr_pos, "> ")); + xact->pos->beg_pos, curr_pos, "> ")); } throw; } } expr_t::ptr_op_t instance_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { return context.scope.lookup(kind, name); } std::size_t journal_t::parse(std::istream& in, - scope_t& scope, - account_t * master, - const path * original_file, - bool strict) + scope_t& scope, + account_t * master, + const path * original_file, + bool strict) { TRACE_START(parsing_total, 1, "Total time spent parsing text:"); diff --git a/src/timelog.cc b/src/timelog.cc index 217aa581..241824cd 100644 --- a/src/timelog.cc +++ b/src/timelog.cc @@ -41,8 +41,8 @@ namespace ledger { namespace { void clock_out_from_timelog(std::list<time_xact_t>& time_xacts, - time_xact_t out_event, - journal_t& journal) + time_xact_t out_event, + journal_t& journal) { time_xact_t event; @@ -55,29 +55,29 @@ namespace { } else if (! out_event.account) { throw parse_error - (_("When multiple check-ins are active, checking out requires an account")); + (_("When multiple check-ins are active, checking out requires an account")); } else { bool found = false; for (std::list<time_xact_t>::iterator i = time_xacts.begin(); - i != time_xacts.end(); - i++) - if (out_event.account == (*i).account) { - event = *i; - found = true; - time_xacts.erase(i); - break; - } + i != time_xacts.end(); + i++) + if (out_event.account == (*i).account) { + event = *i; + found = true; + time_xacts.erase(i); + break; + } if (! found) - throw parse_error - (_("Timelog check-out event does not match any current check-ins")); + throw parse_error + (_("Timelog check-out event does not match any current check-ins")); } if (out_event.checkin < event.checkin) throw parse_error - (_("Timelog check-out date less than corresponding check-in")); + (_("Timelog check-out date less than corresponding check-in")); if (! out_event.desc.empty() && event.desc.empty()) { event.desc = out_event.desc; @@ -98,7 +98,7 @@ namespace { char buf[32]; std::sprintf(buf, "%lds", long((out_event.checkin - event.checkin) - .total_seconds())); + .total_seconds())); amount_t amt; amt.parse(buf); VERIFY(amt.valid()); @@ -128,8 +128,8 @@ time_log_t::~time_log_t() foreach (account_t * account, accounts) clock_out_from_timelog(time_xacts, - time_xact_t(none, CURRENT_TIME(), account), - journal); + time_xact_t(none, CURRENT_TIME(), account), + journal); assert(time_xacts.empty()); } @@ -140,7 +140,7 @@ void time_log_t::clock_in(time_xact_t event) if (! time_xacts.empty()) { foreach (time_xact_t& time_xact, time_xacts) { if (event.account == time_xact.account) - throw parse_error(_("Cannot double check-in to the same account")); + throw parse_error(_("Cannot double check-in to the same account")); } } diff --git a/src/timelog.h b/src/timelog.h index caa23ec0..79629408 100644 --- a/src/timelog.h +++ b/src/timelog.h @@ -64,14 +64,14 @@ public: TRACE_CTOR(time_xact_t, ""); } time_xact_t(const optional<position_t>& _position, - const datetime_t& _checkin, - account_t * _account = NULL, - const string& _desc = "", - const string& _note = "") + const datetime_t& _checkin, + account_t * _account = NULL, + const string& _desc = "", + const string& _note = "") : checkin(_checkin), account(_account), desc(_desc), note(_note), position(_position ? *_position : position_t()) { TRACE_CTOR(time_xact_t, - "position_t, datetime_t, account_t *, string, string"); + "position_t, datetime_t, account_t *, string, string"); } time_xact_t(const time_xact_t& xact) : checkin(xact.checkin), account(xact.account), @@ -86,7 +86,7 @@ public: class time_log_t { std::list<time_xact_t> time_xacts; - journal_t& journal; + journal_t& journal; public: time_log_t(journal_t& _journal) : journal(_journal) { diff --git a/src/times.cc b/src/times.cc index 60e8e7cc..26e1dc21 100644 --- a/src/times.cc +++ b/src/times.cc @@ -60,17 +60,17 @@ namespace { temporal_io_t(const char * _fmt_str, bool _input) : fmt_str(_fmt_str), - traits(icontains(fmt_str, "%y"), - icontains(fmt_str, "%m") || icontains(fmt_str, "%b"), - icontains(fmt_str, "%d")), - input(_input) { + traits(icontains(fmt_str, "%y"), + icontains(fmt_str, "%m") || icontains(fmt_str, "%b"), + icontains(fmt_str, "%d")), + input(_input) { #if defined(USE_BOOST_FACETS) if (input) { - input_facet = new InputFacetType(fmt_str); - input_stream.imbue(std::locale(std::locale::classic(), input_facet)); + input_facet = new InputFacetType(fmt_str); + input_stream.imbue(std::locale(std::locale::classic(), input_facet)); } else { - output_facet = new OutputFacetType(fmt_str); - output_stream.imbue(std::locale(std::locale::classic(), output_facet)); + output_facet = new OutputFacetType(fmt_str); + output_stream.imbue(std::locale(std::locale::classic(), output_facet)); } #endif // USE_BOOST_FACETS } @@ -78,14 +78,14 @@ namespace { void set_format(const char * fmt) { fmt_str = fmt; traits = date_traits_t(icontains(fmt_str, "%y"), - icontains(fmt_str, "%m") || - icontains(fmt_str, "%b"), - icontains(fmt_str, "%d")); + icontains(fmt_str, "%m") || + icontains(fmt_str, "%b"), + icontains(fmt_str, "%d")); #if defined(USE_BOOST_FACETS) if (input) - input_facet->format(fmt_str); + input_facet->format(fmt_str); else - output_facet->format(fmt_str); + output_facet->format(fmt_str); #endif // USE_BOOST_FACETS } @@ -110,7 +110,7 @@ namespace { template <> datetime_t temporal_io_t<datetime_t, posix_time::time_input_facet, - posix_time::time_facet> + posix_time::time_facet> ::parse(const char * str) { #if defined(USE_BOOST_FACETS) @@ -122,15 +122,15 @@ namespace { input_stream >> when; #if defined(DEBUG_ON) if (when.is_not_a_date_time()) - DEBUG("times.parse", "Failed to parse date/time '" << str - << "' using pattern '" << fmt_str << "'"); + DEBUG("times.parse", "Failed to parse date/time '" << str + << "' using pattern '" << fmt_str << "'"); #endif if (! when.is_not_a_date_time() && - input_stream.good() && ! input_stream.eof() && - input_stream.peek() != EOF) { - DEBUG("times.parse", "This string has leftovers: '" << str << "'"); - return datetime_t(); + input_stream.good() && ! input_stream.eof() && + input_stream.peek() != EOF) { + DEBUG("times.parse", "This string has leftovers: '" << str << "'"); + return datetime_t(); } return when; #else // USE_BOOST_FACETS @@ -145,7 +145,7 @@ namespace { template <> date_t temporal_io_t<date_t, gregorian::date_input_facet, - gregorian::date_facet> + gregorian::date_facet> ::parse(const char * str) { #if defined(USE_BOOST_FACETS) @@ -157,21 +157,21 @@ namespace { input_stream >> when; #if defined(DEBUG_ON) if (when.is_not_a_date()) - DEBUG("times.parse", "Failed to parse date '" << str - << "' using pattern '" << fmt_str << "'"); + DEBUG("times.parse", "Failed to parse date '" << str + << "' using pattern '" << fmt_str << "'"); #endif if (! when.is_not_a_date() && - input_stream.good() && ! input_stream.eof() && - input_stream.peek() != EOF) { - DEBUG("times.parse", "This string has leftovers: '" << str << "'"); - return date_t(); + input_stream.good() && ! input_stream.eof() && + input_stream.peek() != EOF) { + DEBUG("times.parse", "This string has leftovers: '" << str << "'"); + return date_t(); } return when; #else // USE_BOOST_FACETS std::tm data; std::memset(&data, 0, sizeof(std::tm)); - data.tm_mday = 1; // some formats have no day + data.tm_mday = 1; // some formats have no day if (strptime(str, fmt_str, &data)) return gregorian::date_from_tm(data); else @@ -180,9 +180,9 @@ namespace { } typedef temporal_io_t<datetime_t, posix_time::time_input_facet, - posix_time::time_facet> datetime_io_t; + posix_time::time_facet> datetime_io_t; typedef temporal_io_t<date_t, gregorian::date_input_facet, - gregorian::date_facet> date_io_t; + gregorian::date_facet> date_io_t; shared_ptr<datetime_io_t> input_datetime_io; shared_ptr<date_io_t> input_date_io; @@ -194,8 +194,8 @@ namespace { std::vector<shared_ptr<date_io_t> > readers; date_t parse_date_mask_routine(const char * date_str, date_io_t& io, - optional_year year, - date_traits_t * traits = NULL) + optional_year year, + date_traits_t * traits = NULL) { VERIFY(std::strlen(date_str) < 127); @@ -204,7 +204,7 @@ namespace { for (char * p = buf; *p; p++) if (*p == '.' || *p == '-') - *p = '/'; + *p = '/'; date_t when = io.parse(buf); @@ -219,41 +219,41 @@ namespace { const char * p = when_str.c_str(); const char * q = buf; for (; *p && *q; p++, q++) { - if (*p != *q && *p == '0') p++; - if (! *p || *p != *q) break; + if (*p != *q && *p == '0') p++; + if (! *p || *p != *q) break; } if (*p != '\0' || *q != '\0') - throw_(date_error, _("Invalid date: %1") << date_str); + throw_(date_error, _("Invalid date: %1") << date_str); if (traits) - *traits = io.traits; + *traits = io.traits; if (! io.traits.has_year) { - when = date_t(year ? *year : CURRENT_DATE().year(), - when.month(), when.day()); + when = date_t(year ? *year : CURRENT_DATE().year(), + when.month(), when.day()); - if (! year && when.month() > CURRENT_DATE().month()) - when -= gregorian::years(1); + if (! year && when.month() > CURRENT_DATE().month()) + when -= gregorian::years(1); } } return when; } date_t parse_date_mask(const char * date_str, optional_year year, - date_traits_t * traits = NULL) + date_traits_t * traits = NULL) { if (input_date_io.get()) { date_t when = parse_date_mask_routine(date_str, *input_date_io.get(), - year, traits); + year, traits); if (! when.is_not_a_date()) - return when; + return when; } foreach (shared_ptr<date_io_t>& reader, readers) { date_t when = parse_date_mask_routine(date_str, *reader.get(), - year, traits); + year, traits); if (! when.is_not_a_date()) - return when; + return when; } throw_(date_error, _("Invalid date: %1") << date_str); @@ -344,8 +344,8 @@ date_t date_specifier_t::begin(const optional_year& current_year) const // wday in that month; if the year is set, then in that year. return gregorian::date(static_cast<date_t::year_type>(the_year), - static_cast<date_t::month_type>(the_month), - static_cast<date_t::day_type>(the_day)); + static_cast<date_t::month_type>(the_month), + static_cast<date_t::day_type>(the_day)); } date_t date_specifier_t::end(const optional_year& current_year) const @@ -363,7 +363,7 @@ date_t date_specifier_t::end(const optional_year& current_year) const } std::ostream& operator<<(std::ostream& out, - const date_duration_t& duration) + const date_duration_t& duration) { if (duration.quantum == date_duration_t::DAYS) out << duration.length << " day(s)"; @@ -395,194 +395,194 @@ class date_parser_t struct token_t { enum kind_t { - UNKNOWN, - - TOK_DATE, - TOK_INT, - TOK_SLASH, - TOK_DASH, - TOK_DOT, - - TOK_A_YEAR, - TOK_A_MONTH, - TOK_A_WDAY, - - TOK_SINCE, - TOK_UNTIL, - TOK_IN, - TOK_THIS, - TOK_NEXT, - TOK_LAST, - TOK_EVERY, - - TOK_TODAY, - TOK_TOMORROW, - TOK_YESTERDAY, - - TOK_YEAR, - TOK_QUARTER, - TOK_MONTH, - TOK_WEEK, - TOK_DAY, - - TOK_YEARLY, - TOK_QUARTERLY, - TOK_BIMONTHLY, - TOK_MONTHLY, - TOK_BIWEEKLY, - TOK_WEEKLY, - TOK_DAILY, - - TOK_YEARS, - TOK_QUARTERS, - TOK_MONTHS, - TOK_WEEKS, - TOK_DAYS, - - END_REACHED + UNKNOWN, + + TOK_DATE, + TOK_INT, + TOK_SLASH, + TOK_DASH, + TOK_DOT, + + TOK_A_YEAR, + TOK_A_MONTH, + TOK_A_WDAY, + + TOK_SINCE, + TOK_UNTIL, + TOK_IN, + TOK_THIS, + TOK_NEXT, + TOK_LAST, + TOK_EVERY, + + TOK_TODAY, + TOK_TOMORROW, + TOK_YESTERDAY, + + TOK_YEAR, + TOK_QUARTER, + TOK_MONTH, + TOK_WEEK, + TOK_DAY, + + TOK_YEARLY, + TOK_QUARTERLY, + TOK_BIMONTHLY, + TOK_MONTHLY, + TOK_BIWEEKLY, + TOK_WEEKLY, + TOK_DAILY, + + TOK_YEARS, + TOK_QUARTERS, + TOK_MONTHS, + TOK_WEEKS, + TOK_DAYS, + + END_REACHED } kind; typedef variant<unsigned short, - string, - date_specifier_t::year_type, - date_time::months_of_year, - date_time::weekdays, - date_specifier_t> content_t; + string, + date_specifier_t::year_type, + date_time::months_of_year, + date_time::weekdays, + date_specifier_t> content_t; optional<content_t> value; explicit token_t(kind_t _kind = UNKNOWN, - const optional<content_t>& _value = - content_t(empty_string)) - : kind(_kind), value(_value) { - TRACE_CTOR(date_parser_t::lexer_t::token_t, ""); + const optional<content_t>& _value = + content_t(empty_string)) + : kind(_kind), value(_value) { + TRACE_CTOR(date_parser_t::lexer_t::token_t, ""); } token_t(const token_t& tok) - : kind(tok.kind), value(tok.value) { - TRACE_CTOR(date_parser_t::lexer_t::token_t, "copy"); + : kind(tok.kind), value(tok.value) { + TRACE_CTOR(date_parser_t::lexer_t::token_t, "copy"); } ~token_t() throw() { - TRACE_DTOR(date_parser_t::lexer_t::token_t); + TRACE_DTOR(date_parser_t::lexer_t::token_t); } token_t& operator=(const token_t& tok) { - if (this != &tok) { - kind = tok.kind; - value = tok.value; - } - return *this; + if (this != &tok) { + kind = tok.kind; + value = tok.value; + } + return *this; } operator bool() const { - return kind != END_REACHED; + return kind != END_REACHED; } string to_string() const { - std::ostringstream out; - - switch (kind) { - case UNKNOWN: - out << boost::get<string>(*value); - break; - case TOK_DATE: - return boost::get<date_specifier_t>(*value).to_string(); - case TOK_INT: - out << boost::get<unsigned short>(*value); - break; - case TOK_SLASH: return "/"; - case TOK_DASH: return "-"; - case TOK_DOT: return "."; - case TOK_A_YEAR: - out << boost::get<date_specifier_t::year_type>(*value); - break; - case TOK_A_MONTH: - out << date_specifier_t::month_type - (boost::get<date_time::months_of_year>(*value)); - break; - case TOK_A_WDAY: - out << date_specifier_t::day_of_week_type - (boost::get<date_time::weekdays>(*value)); - break; - case TOK_SINCE: return "since"; - case TOK_UNTIL: return "until"; - case TOK_IN: return "in"; - case TOK_THIS: return "this"; - case TOK_NEXT: return "next"; - case TOK_LAST: return "last"; - case TOK_EVERY: return "every"; - case TOK_TODAY: return "today"; - case TOK_TOMORROW: return "tomorrow"; - case TOK_YESTERDAY: return "yesterday"; - case TOK_YEAR: return "year"; - case TOK_QUARTER: return "quarter"; - case TOK_MONTH: return "month"; - case TOK_WEEK: return "week"; - case TOK_DAY: return "day"; - case TOK_YEARLY: return "yearly"; - case TOK_QUARTERLY: return "quarterly"; - case TOK_BIMONTHLY: return "bimonthly"; - case TOK_MONTHLY: return "monthly"; - case TOK_BIWEEKLY: return "biweekly"; - case TOK_WEEKLY: return "weekly"; - case TOK_DAILY: return "daily"; - case TOK_YEARS: return "years"; - case TOK_QUARTERS: return "quarters"; - case TOK_MONTHS: return "months"; - case TOK_WEEKS: return "weeks"; - case TOK_DAYS: return "days"; - case END_REACHED: return "<EOF>"; - default: - assert(false); - return empty_string; - } - - return out.str(); + std::ostringstream out; + + switch (kind) { + case UNKNOWN: + out << boost::get<string>(*value); + break; + case TOK_DATE: + return boost::get<date_specifier_t>(*value).to_string(); + case TOK_INT: + out << boost::get<unsigned short>(*value); + break; + case TOK_SLASH: return "/"; + case TOK_DASH: return "-"; + case TOK_DOT: return "."; + case TOK_A_YEAR: + out << boost::get<date_specifier_t::year_type>(*value); + break; + case TOK_A_MONTH: + out << date_specifier_t::month_type + (boost::get<date_time::months_of_year>(*value)); + break; + case TOK_A_WDAY: + out << date_specifier_t::day_of_week_type + (boost::get<date_time::weekdays>(*value)); + break; + case TOK_SINCE: return "since"; + case TOK_UNTIL: return "until"; + case TOK_IN: return "in"; + case TOK_THIS: return "this"; + case TOK_NEXT: return "next"; + case TOK_LAST: return "last"; + case TOK_EVERY: return "every"; + case TOK_TODAY: return "today"; + case TOK_TOMORROW: return "tomorrow"; + case TOK_YESTERDAY: return "yesterday"; + case TOK_YEAR: return "year"; + case TOK_QUARTER: return "quarter"; + case TOK_MONTH: return "month"; + case TOK_WEEK: return "week"; + case TOK_DAY: return "day"; + case TOK_YEARLY: return "yearly"; + case TOK_QUARTERLY: return "quarterly"; + case TOK_BIMONTHLY: return "bimonthly"; + case TOK_MONTHLY: return "monthly"; + case TOK_BIWEEKLY: return "biweekly"; + case TOK_WEEKLY: return "weekly"; + case TOK_DAILY: return "daily"; + case TOK_YEARS: return "years"; + case TOK_QUARTERS: return "quarters"; + case TOK_MONTHS: return "months"; + case TOK_WEEKS: return "weeks"; + case TOK_DAYS: return "days"; + case END_REACHED: return "<EOF>"; + default: + assert(false); + return empty_string; + } + + return out.str(); } void dump(std::ostream& out) const { - switch (kind) { - case UNKNOWN: out << "UNKNOWN"; break; - case TOK_DATE: out << "TOK_DATE"; break; - case TOK_INT: out << "TOK_INT"; break; - case TOK_SLASH: out << "TOK_SLASH"; break; - case TOK_DASH: out << "TOK_DASH"; break; - case TOK_DOT: out << "TOK_DOT"; break; - case TOK_A_YEAR: out << "TOK_A_YEAR"; break; - case TOK_A_MONTH: out << "TOK_A_MONTH"; break; - case TOK_A_WDAY: out << "TOK_A_WDAY"; break; - case TOK_SINCE: out << "TOK_SINCE"; break; - case TOK_UNTIL: out << "TOK_UNTIL"; break; - case TOK_IN: out << "TOK_IN"; break; - case TOK_THIS: out << "TOK_THIS"; break; - case TOK_NEXT: out << "TOK_NEXT"; break; - case TOK_LAST: out << "TOK_LAST"; break; - case TOK_EVERY: out << "TOK_EVERY"; break; - case TOK_TODAY: out << "TOK_TODAY"; break; - case TOK_TOMORROW: out << "TOK_TOMORROW"; break; - case TOK_YESTERDAY: out << "TOK_YESTERDAY"; break; - case TOK_YEAR: out << "TOK_YEAR"; break; - case TOK_QUARTER: out << "TOK_QUARTER"; break; - case TOK_MONTH: out << "TOK_MONTH"; break; - case TOK_WEEK: out << "TOK_WEEK"; break; - case TOK_DAY: out << "TOK_DAY"; break; - case TOK_YEARLY: out << "TOK_YEARLY"; break; - case TOK_QUARTERLY: out << "TOK_QUARTERLY"; break; - case TOK_BIMONTHLY: out << "TOK_BIMONTHLY"; break; - case TOK_MONTHLY: out << "TOK_MONTHLY"; break; - case TOK_BIWEEKLY: out << "TOK_BIWEEKLY"; break; - case TOK_WEEKLY: out << "TOK_WEEKLY"; break; - case TOK_DAILY: out << "TOK_DAILY"; break; - case TOK_YEARS: out << "TOK_YEARS"; break; - case TOK_QUARTERS: out << "TOK_QUARTERS"; break; - case TOK_MONTHS: out << "TOK_MONTHS"; break; - case TOK_WEEKS: out << "TOK_WEEKS"; break; - case TOK_DAYS: out << "TOK_DAYS"; break; - case END_REACHED: out << "END_REACHED"; break; - default: - assert(false); - break; - } + switch (kind) { + case UNKNOWN: out << "UNKNOWN"; break; + case TOK_DATE: out << "TOK_DATE"; break; + case TOK_INT: out << "TOK_INT"; break; + case TOK_SLASH: out << "TOK_SLASH"; break; + case TOK_DASH: out << "TOK_DASH"; break; + case TOK_DOT: out << "TOK_DOT"; break; + case TOK_A_YEAR: out << "TOK_A_YEAR"; break; + case TOK_A_MONTH: out << "TOK_A_MONTH"; break; + case TOK_A_WDAY: out << "TOK_A_WDAY"; break; + case TOK_SINCE: out << "TOK_SINCE"; break; + case TOK_UNTIL: out << "TOK_UNTIL"; break; + case TOK_IN: out << "TOK_IN"; break; + case TOK_THIS: out << "TOK_THIS"; break; + case TOK_NEXT: out << "TOK_NEXT"; break; + case TOK_LAST: out << "TOK_LAST"; break; + case TOK_EVERY: out << "TOK_EVERY"; break; + case TOK_TODAY: out << "TOK_TODAY"; break; + case TOK_TOMORROW: out << "TOK_TOMORROW"; break; + case TOK_YESTERDAY: out << "TOK_YESTERDAY"; break; + case TOK_YEAR: out << "TOK_YEAR"; break; + case TOK_QUARTER: out << "TOK_QUARTER"; break; + case TOK_MONTH: out << "TOK_MONTH"; break; + case TOK_WEEK: out << "TOK_WEEK"; break; + case TOK_DAY: out << "TOK_DAY"; break; + case TOK_YEARLY: out << "TOK_YEARLY"; break; + case TOK_QUARTERLY: out << "TOK_QUARTERLY"; break; + case TOK_BIMONTHLY: out << "TOK_BIMONTHLY"; break; + case TOK_MONTHLY: out << "TOK_MONTHLY"; break; + case TOK_BIWEEKLY: out << "TOK_BIWEEKLY"; break; + case TOK_WEEKLY: out << "TOK_WEEKLY"; break; + case TOK_DAILY: out << "TOK_DAILY"; break; + case TOK_YEARS: out << "TOK_YEARS"; break; + case TOK_QUARTERS: out << "TOK_QUARTERS"; break; + case TOK_MONTHS: out << "TOK_MONTHS"; break; + case TOK_WEEKS: out << "TOK_WEEKS"; break; + case TOK_DAYS: out << "TOK_DAYS"; break; + case END_REACHED: out << "END_REACHED"; break; + default: + assert(false); + break; + } } void unexpected(); @@ -592,14 +592,14 @@ class date_parser_t token_t token_cache; lexer_t(string::const_iterator _begin, - string::const_iterator _end) + string::const_iterator _end) : begin(_begin), end(_end) { TRACE_CTOR(date_parser_t::lexer_t, ""); } lexer_t(const lexer_t& lexer) : begin(lexer.begin), end(lexer.end), - token_cache(lexer.token_cache) + token_cache(lexer.token_cache) { TRACE_CTOR(date_parser_t::lexer_t, "copy"); } @@ -614,7 +614,7 @@ class date_parser_t } token_t peek_token() { if (token_cache.kind == token_t::UNKNOWN) - token_cache = next_token(); + token_cache = next_token(); return token_cache; } }; @@ -642,7 +642,7 @@ private: }; void date_parser_t::determine_when(date_parser_t::lexer_t::token_t& tok, - date_specifier_t& specifier) + date_specifier_t& specifier) { switch (tok.kind) { case lexer_t::token_t::TOK_DATE: @@ -680,8 +680,8 @@ date_interval_t date_parser_t::parse() optional<date_specifier_t> inclusion_specifier; date_interval_t period; - date_t today = CURRENT_DATE(); - bool end_inclusive = false; + date_t today = CURRENT_DATE(); + bool end_inclusive = false; for (lexer_t::token_t tok = lexer.next_token(); tok.kind != lexer_t::token_t::END_REACHED; @@ -697,77 +697,77 @@ date_interval_t date_parser_t::parse() case lexer_t::token_t::TOK_DATE: if (! inclusion_specifier) - inclusion_specifier = date_specifier_t(); + inclusion_specifier = date_specifier_t(); determine_when(tok, *inclusion_specifier); break; case lexer_t::token_t::TOK_INT: if (! inclusion_specifier) - inclusion_specifier = date_specifier_t(); + inclusion_specifier = date_specifier_t(); determine_when(tok, *inclusion_specifier); break; case lexer_t::token_t::TOK_A_YEAR: if (! inclusion_specifier) - inclusion_specifier = date_specifier_t(); + inclusion_specifier = date_specifier_t(); determine_when(tok, *inclusion_specifier); break; case lexer_t::token_t::TOK_A_MONTH: if (! inclusion_specifier) - inclusion_specifier = date_specifier_t(); + inclusion_specifier = date_specifier_t(); determine_when(tok, *inclusion_specifier); break; case lexer_t::token_t::TOK_A_WDAY: if (! inclusion_specifier) - inclusion_specifier = date_specifier_t(); + inclusion_specifier = date_specifier_t(); determine_when(tok, *inclusion_specifier); break; case lexer_t::token_t::TOK_DASH: if (inclusion_specifier) { - since_specifier = inclusion_specifier; - until_specifier = date_specifier_t(); - inclusion_specifier = none; + since_specifier = inclusion_specifier; + until_specifier = date_specifier_t(); + inclusion_specifier = none; - tok = lexer.next_token(); - determine_when(tok, *until_specifier); + tok = lexer.next_token(); + determine_when(tok, *until_specifier); - // The dash operator is special: it has an _inclusive_ end. - end_inclusive = true; + // The dash operator is special: it has an _inclusive_ end. + end_inclusive = true; } else { - tok.unexpected(); + tok.unexpected(); } break; case lexer_t::token_t::TOK_SINCE: if (since_specifier) { - tok.unexpected(); + tok.unexpected(); } else { - since_specifier = date_specifier_t(); - tok = lexer.next_token(); - determine_when(tok, *since_specifier); + since_specifier = date_specifier_t(); + tok = lexer.next_token(); + determine_when(tok, *since_specifier); } break; case lexer_t::token_t::TOK_UNTIL: if (until_specifier) { - tok.unexpected(); + tok.unexpected(); } else { - until_specifier = date_specifier_t(); - tok = lexer.next_token(); - determine_when(tok, *until_specifier); + until_specifier = date_specifier_t(); + tok = lexer.next_token(); + determine_when(tok, *until_specifier); } break; case lexer_t::token_t::TOK_IN: if (inclusion_specifier) { - tok.unexpected(); + tok.unexpected(); } else { - inclusion_specifier = date_specifier_t(); - tok = lexer.next_token(); - determine_when(tok, *inclusion_specifier); + inclusion_specifier = date_specifier_t(); + tok = lexer.next_token(); + determine_when(tok, *inclusion_specifier); } break; @@ -776,90 +776,90 @@ date_interval_t date_parser_t::parse() case lexer_t::token_t::TOK_LAST: { int8_t adjust = 0; if (tok.kind == lexer_t::token_t::TOK_NEXT) - adjust = 1; + adjust = 1; else if (tok.kind == lexer_t::token_t::TOK_LAST) - adjust = -1; + adjust = -1; tok = lexer.next_token(); switch (tok.kind) { case lexer_t::token_t::TOK_INT: - // jww (2009-11-18): Allow things like "last 5 weeks" - assert(! "Need to allow for expressions like \"last 5 weeks\""); - tok.unexpected(); - break; + // jww (2009-11-18): Allow things like "last 5 weeks" + assert(! "Need to allow for expressions like \"last 5 weeks\""); + tok.unexpected(); + break; case lexer_t::token_t::TOK_A_MONTH: { - inclusion_specifier = date_specifier_t(); - determine_when(tok, *inclusion_specifier); - - date_t temp(today.year(), *inclusion_specifier->month, 1); - temp += gregorian::years(adjust); - inclusion_specifier = - date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), - temp.month()); - break; + inclusion_specifier = date_specifier_t(); + determine_when(tok, *inclusion_specifier); + + date_t temp(today.year(), *inclusion_specifier->month, 1); + temp += gregorian::years(adjust); + inclusion_specifier = + date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), + temp.month()); + break; } case lexer_t::token_t::TOK_A_WDAY: { - inclusion_specifier = date_specifier_t(); - determine_when(tok, *inclusion_specifier); - - date_t temp = - date_duration_t::find_nearest(today, date_duration_t::WEEKS); - while (temp.day_of_week() != inclusion_specifier->wday) - temp += gregorian::days(1); - temp += gregorian::days(7 * adjust); - inclusion_specifier = date_specifier_t(temp); - break; + inclusion_specifier = date_specifier_t(); + determine_when(tok, *inclusion_specifier); + + date_t temp = + date_duration_t::find_nearest(today, date_duration_t::WEEKS); + while (temp.day_of_week() != inclusion_specifier->wday) + temp += gregorian::days(1); + temp += gregorian::days(7 * adjust); + inclusion_specifier = date_specifier_t(temp); + break; } case lexer_t::token_t::TOK_YEAR: { - date_t temp(today); - temp += gregorian::years(adjust); - inclusion_specifier = - date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year())); - break; + date_t temp(today); + temp += gregorian::years(adjust); + inclusion_specifier = + date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year())); + break; } case lexer_t::token_t::TOK_QUARTER: { - date_t temp = - date_duration_t::find_nearest(today, date_duration_t::QUARTERS); - temp += gregorian::months(3 * adjust); - inclusion_specifier = - date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), - temp.month()); + date_t temp = + date_duration_t::find_nearest(today, date_duration_t::QUARTERS); + temp += gregorian::months(3 * adjust); + inclusion_specifier = + date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), + temp.month()); #if 0 - period.duration = date_duration_t(date_duration_t::QUARTERS, 1); + period.duration = date_duration_t(date_duration_t::QUARTERS, 1); #endif - break; + break; } case lexer_t::token_t::TOK_WEEK: { - date_t temp = - date_duration_t::find_nearest(today, date_duration_t::WEEKS); - temp += gregorian::days(7 * adjust); - inclusion_specifier = date_specifier_t(today); + date_t temp = + date_duration_t::find_nearest(today, date_duration_t::WEEKS); + temp += gregorian::days(7 * adjust); + inclusion_specifier = date_specifier_t(today); #if 0 - period.duration = date_duration_t(date_duration_t::WEEKS, 1); + period.duration = date_duration_t(date_duration_t::WEEKS, 1); #endif - break; + break; } case lexer_t::token_t::TOK_DAY: { - date_t temp(today); - temp += gregorian::days(adjust); - inclusion_specifier = date_specifier_t(temp); - break; + date_t temp(today); + temp += gregorian::days(adjust); + inclusion_specifier = date_specifier_t(temp); + break; } default: case lexer_t::token_t::TOK_MONTH: { - date_t temp(today); - temp += gregorian::months(adjust); - inclusion_specifier = - date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), - temp.month()); - break; + date_t temp(today); + temp += gregorian::months(adjust); + inclusion_specifier = + date_specifier_t(static_cast<date_specifier_t::year_type>(temp.year()), + temp.month()); + break; } } } @@ -877,49 +877,49 @@ date_interval_t date_parser_t::parse() case lexer_t::token_t::TOK_EVERY: tok = lexer.next_token(); if (tok == lexer_t::token_t::TOK_INT) { - int quantity = boost::get<unsigned short>(*tok.value); - tok = lexer.next_token(); - switch (tok.kind) { - case lexer_t::token_t::TOK_YEARS: - period.duration = date_duration_t(date_duration_t::YEARS, quantity); - break; - case lexer_t::token_t::TOK_QUARTERS: - period.duration = date_duration_t(date_duration_t::QUARTERS, quantity); - break; - case lexer_t::token_t::TOK_MONTHS: - period.duration = date_duration_t(date_duration_t::MONTHS, quantity); - break; - case lexer_t::token_t::TOK_WEEKS: - period.duration = date_duration_t(date_duration_t::WEEKS, quantity); - break; - case lexer_t::token_t::TOK_DAYS: - period.duration = date_duration_t(date_duration_t::DAYS, quantity); - break; - default: - tok.unexpected(); - break; - } + int quantity = boost::get<unsigned short>(*tok.value); + tok = lexer.next_token(); + switch (tok.kind) { + case lexer_t::token_t::TOK_YEARS: + period.duration = date_duration_t(date_duration_t::YEARS, quantity); + break; + case lexer_t::token_t::TOK_QUARTERS: + period.duration = date_duration_t(date_duration_t::QUARTERS, quantity); + break; + case lexer_t::token_t::TOK_MONTHS: + period.duration = date_duration_t(date_duration_t::MONTHS, quantity); + break; + case lexer_t::token_t::TOK_WEEKS: + period.duration = date_duration_t(date_duration_t::WEEKS, quantity); + break; + case lexer_t::token_t::TOK_DAYS: + period.duration = date_duration_t(date_duration_t::DAYS, quantity); + break; + default: + tok.unexpected(); + break; + } } else { - switch (tok.kind) { - case lexer_t::token_t::TOK_YEAR: - period.duration = date_duration_t(date_duration_t::YEARS, 1); - break; - case lexer_t::token_t::TOK_QUARTER: - period.duration = date_duration_t(date_duration_t::QUARTERS, 1); - break; - case lexer_t::token_t::TOK_MONTH: - period.duration = date_duration_t(date_duration_t::MONTHS, 1); - break; - case lexer_t::token_t::TOK_WEEK: - period.duration = date_duration_t(date_duration_t::WEEKS, 1); - break; - case lexer_t::token_t::TOK_DAY: - period.duration = date_duration_t(date_duration_t::DAYS, 1); - break; - default: - tok.unexpected(); - break; - } + switch (tok.kind) { + case lexer_t::token_t::TOK_YEAR: + period.duration = date_duration_t(date_duration_t::YEARS, 1); + break; + case lexer_t::token_t::TOK_QUARTER: + period.duration = date_duration_t(date_duration_t::QUARTERS, 1); + break; + case lexer_t::token_t::TOK_MONTH: + period.duration = date_duration_t(date_duration_t::MONTHS, 1); + break; + case lexer_t::token_t::TOK_WEEK: + period.duration = date_duration_t(date_duration_t::WEEKS, 1); + break; + case lexer_t::token_t::TOK_DAY: + period.duration = date_duration_t(date_duration_t::DAYS, 1); + break; + default: + tok.unexpected(); + break; + } } break; @@ -983,13 +983,13 @@ void date_interval_t::resolve_end() if (start && ! end_of_duration) { end_of_duration = duration->add(*start); DEBUG("times.interval", - "stabilize: end_of_duration = " << *end_of_duration); + "stabilize: end_of_duration = " << *end_of_duration); } if (finish && *end_of_duration > *finish) { end_of_duration = finish; DEBUG("times.interval", - "stabilize: end_of_duration reset to end: " << *end_of_duration); + "stabilize: end_of_duration reset to end: " << *end_of_duration); } if (start && ! next) { @@ -1009,9 +1009,9 @@ date_t date_duration_t::find_nearest(const date_t& date, skip_quantum_t skip) case date_duration_t::QUARTERS: result = date_t(date.year(), date.month(), 1); while (result.month() != gregorian::Jan && - result.month() != gregorian::Apr && - result.month() != gregorian::Jul && - result.month() != gregorian::Oct) + result.month() != gregorian::Apr && + result.month() != gregorian::Jul && + result.month() != gregorian::Oct) result -= gregorian::months(1); break; case date_duration_t::MONTHS: @@ -1043,7 +1043,7 @@ void date_interval_t::stabilize(const optional<date_t>& date) DEBUG("times.interval", "stabilize: date passed, but not aligned"); if (duration) { DEBUG("times.interval", - "stabilize: aligning with a duration: " << *duration); + "stabilize: aligning with a duration: " << *duration); // The interval object has not been seeded with a start date yet, so // find the nearest period before on on date which fits, if possible. @@ -1057,71 +1057,71 @@ void date_interval_t::stabilize(const optional<date_t>& date) #if defined(DEBUG_ON) if (initial_start) - DEBUG("times.interval", - "stabilize: initial_start = " << *initial_start); + DEBUG("times.interval", + "stabilize: initial_start = " << *initial_start); if (initial_finish) - DEBUG("times.interval", - "stabilize: initial_finish = " << *initial_finish); + DEBUG("times.interval", + "stabilize: initial_finish = " << *initial_finish); #endif date_t when = start ? *start : *date; if (duration->quantum == date_duration_t::MONTHS || - duration->quantum == date_duration_t::QUARTERS || - duration->quantum == date_duration_t::YEARS) { - DEBUG("times.interval", - "stabilize: monthly, quarterly or yearly duration"); - start = date_duration_t::find_nearest(when, duration->quantum); + duration->quantum == date_duration_t::QUARTERS || + duration->quantum == date_duration_t::YEARS) { + DEBUG("times.interval", + "stabilize: monthly, quarterly or yearly duration"); + start = date_duration_t::find_nearest(when, duration->quantum); } else { - DEBUG("times.interval", "stabilize: daily or weekly duration"); - start = date_duration_t::find_nearest(when - gregorian::days(400), - duration->quantum); + DEBUG("times.interval", "stabilize: daily or weekly duration"); + start = date_duration_t::find_nearest(when - gregorian::days(400), + duration->quantum); } DEBUG("times.interval", - "stabilize: beginning start date = " << *start); + "stabilize: beginning start date = " << *start); while (*start < *date) { - date_interval_t next_interval(*this); - ++next_interval; - - if (next_interval.start && *next_interval.start < *date) { - *this = next_interval; - } else { - end_of_duration = none; - next = none; - break; - } + date_interval_t next_interval(*this); + ++next_interval; + + if (next_interval.start && *next_interval.start < *date) { + *this = next_interval; + } else { + end_of_duration = none; + next = none; + break; + } } DEBUG("times.interval", "stabilize: proposed start date = " << *start); if (initial_start && (! start || *start < *initial_start)) { - // Using the discovered start, find the end of the period - resolve_end(); + // Using the discovered start, find the end of the period + resolve_end(); - start = initial_start; - DEBUG("times.interval", "stabilize: start reset to initial start"); + start = initial_start; + DEBUG("times.interval", "stabilize: start reset to initial start"); } if (initial_finish && (! finish || *finish > *initial_finish)) { - finish = initial_finish; - DEBUG("times.interval", "stabilize: finish reset to initial finish"); + finish = initial_finish; + DEBUG("times.interval", "stabilize: finish reset to initial finish"); } #if defined(DEBUG_ON) if (start) - DEBUG("times.interval", "stabilize: final start = " << *start); + DEBUG("times.interval", "stabilize: final start = " << *start); if (finish) - DEBUG("times.interval", "stabilize: final finish = " << *finish); + DEBUG("times.interval", "stabilize: final finish = " << *finish); #endif } else if (range) { if (date) { - start = range->begin(date->year()); - finish = range->end(date->year()); + start = range->begin(date->year()); + finish = range->end(date->year()); } else { - start = range->begin(); - finish = range->end(); + start = range->begin(); + finish = range->end(); } } aligned = true; @@ -1134,7 +1134,7 @@ void date_interval_t::stabilize(const optional<date_t>& date) if (! start && ! finish) throw_(date_error, - _("Invalid date interval: neither start, nor finish, nor duration")); + _("Invalid date interval: neither start, nor finish, nor duration")); } else { resolve_end(); } @@ -1146,7 +1146,7 @@ bool date_interval_t::find_period(const date_t& date) if (finish && date > *finish) { DEBUG("times.interval", - "false: date [" << date << "] > finish [" << *finish << "]"); + "false: date [" << date << "] > finish [" << *finish << "]"); return false; } @@ -1155,15 +1155,15 @@ bool date_interval_t::find_period(const date_t& date) } else if (date < *start) { DEBUG("times.interval", - "false: date [" << date << "] < start [" << *start << "]"); + "false: date [" << date << "] < start [" << *start << "]"); return false; } if (end_of_duration) { if (date < *end_of_duration) { DEBUG("times.interval", - "true: date [" << date << "] < end_of_duration [" - << *end_of_duration << "]"); + "true: date [" << date << "] < end_of_duration [" + << *end_of_duration << "]"); return true; } } else { @@ -1185,17 +1185,17 @@ bool date_interval_t::find_period(const date_t& date) while (date >= scan && (! finish || scan < *finish)) { if (date < end_of_scan) { - start = scan; + start = scan; end_of_duration = end_of_scan; - next = none; + next = none; - DEBUG("times.interval", "true: start = " << *start); + DEBUG("times.interval", "true: start = " << *start); DEBUG("times.interval", "true: end_of_duration = " << *end_of_duration); return true; } - scan = duration->add(scan); + scan = duration->add(scan); end_of_scan = duration->add(scan); } @@ -1211,7 +1211,7 @@ date_interval_t& date_interval_t::operator++() if (! duration) throw_(date_error, - _("Cannot increment a date interval without a duration")); + _("Cannot increment a date interval without a duration")); assert(next); @@ -1319,16 +1319,16 @@ date_parser_t::lexer_t::token_t date_parser_t::lexer_t::next_token() date_traits_t traits; date_t when = parse_date_mask(possible_date.c_str(), none, &traits); if (! when.is_not_a_date()) { - begin = i; - return token_t(token_t::TOK_DATE, - token_t::content_t(date_specifier_t(when, traits))); + begin = i; + return token_t(token_t::TOK_DATE, + token_t::content_t(date_specifier_t(when, traits))); } } catch (date_error&) { if (contains(possible_date, "/") || - contains(possible_date, "-") || - contains(possible_date, ".")) - throw; + contains(possible_date, "-") || + contains(possible_date, ".")) + throw; } } @@ -1337,85 +1337,85 @@ date_parser_t::lexer_t::token_t date_parser_t::lexer_t::next_token() string term; bool alnum = std::isalnum(*begin); for (; (begin != end && ! std::isspace(*begin) && - ((alnum && static_cast<bool>(std::isalnum(*begin))) || - (! alnum && ! static_cast<bool>(std::isalnum(*begin))))); begin++) + ((alnum && static_cast<bool>(std::isalnum(*begin))) || + (! alnum && ! static_cast<bool>(std::isalnum(*begin))))); begin++) term.push_back(*begin); if (! term.empty()) { if (std::isdigit(term[0])) { if (term.length() == 4) - return token_t(token_t::TOK_A_YEAR, - token_t::content_t - (lexical_cast<date_specifier_t::year_type>(term))); + return token_t(token_t::TOK_A_YEAR, + token_t::content_t + (lexical_cast<date_specifier_t::year_type>(term))); else - return token_t(token_t::TOK_INT, - token_t::content_t(lexical_cast<unsigned short>(term))); + return token_t(token_t::TOK_INT, + token_t::content_t(lexical_cast<unsigned short>(term))); } else if (std::isalpha(term[0])) { to_lower(term); if (optional<date_time::months_of_year> month = - string_to_month_of_year(term)) { - return token_t(token_t::TOK_A_MONTH, token_t::content_t(*month)); + string_to_month_of_year(term)) { + return token_t(token_t::TOK_A_MONTH, token_t::content_t(*month)); } else if (optional<date_time::weekdays> wday = - string_to_day_of_week(term)) { - return token_t(token_t::TOK_A_WDAY, token_t::content_t(*wday)); + string_to_day_of_week(term)) { + return token_t(token_t::TOK_A_WDAY, token_t::content_t(*wday)); } else if (term == _("from") || term == _("since")) - return token_t(token_t::TOK_SINCE); + return token_t(token_t::TOK_SINCE); else if (term == _("to") || term == _("until")) - return token_t(token_t::TOK_UNTIL); + return token_t(token_t::TOK_UNTIL); else if (term == _("in")) - return token_t(token_t::TOK_IN); + return token_t(token_t::TOK_IN); else if (term == _("this")) - return token_t(token_t::TOK_THIS); + return token_t(token_t::TOK_THIS); else if (term == _("next")) - return token_t(token_t::TOK_NEXT); + return token_t(token_t::TOK_NEXT); else if (term == _("last")) - return token_t(token_t::TOK_LAST); + return token_t(token_t::TOK_LAST); else if (term == _("every")) - return token_t(token_t::TOK_EVERY); + return token_t(token_t::TOK_EVERY); else if (term == _("today")) - return token_t(token_t::TOK_TODAY); + return token_t(token_t::TOK_TODAY); else if (term == _("tomorrow")) - return token_t(token_t::TOK_TOMORROW); + return token_t(token_t::TOK_TOMORROW); else if (term == _("yesterday")) - return token_t(token_t::TOK_YESTERDAY); + return token_t(token_t::TOK_YESTERDAY); else if (term == _("year")) - return token_t(token_t::TOK_YEAR); + return token_t(token_t::TOK_YEAR); else if (term == _("quarter")) - return token_t(token_t::TOK_QUARTER); + return token_t(token_t::TOK_QUARTER); else if (term == _("month")) - return token_t(token_t::TOK_MONTH); + return token_t(token_t::TOK_MONTH); else if (term == _("week")) - return token_t(token_t::TOK_WEEK); + return token_t(token_t::TOK_WEEK); else if (term == _("day")) - return token_t(token_t::TOK_DAY); + return token_t(token_t::TOK_DAY); else if (term == _("yearly")) - return token_t(token_t::TOK_YEARLY); + return token_t(token_t::TOK_YEARLY); else if (term == _("quarterly")) - return token_t(token_t::TOK_QUARTERLY); + return token_t(token_t::TOK_QUARTERLY); else if (term == _("bimonthly")) - return token_t(token_t::TOK_BIMONTHLY); + return token_t(token_t::TOK_BIMONTHLY); else if (term == _("monthly")) - return token_t(token_t::TOK_MONTHLY); + return token_t(token_t::TOK_MONTHLY); else if (term == _("biweekly")) - return token_t(token_t::TOK_BIWEEKLY); + return token_t(token_t::TOK_BIWEEKLY); else if (term == _("weekly")) - return token_t(token_t::TOK_WEEKLY); + return token_t(token_t::TOK_WEEKLY); else if (term == _("daily")) - return token_t(token_t::TOK_DAILY); + return token_t(token_t::TOK_DAILY); else if (term == _("years")) - return token_t(token_t::TOK_YEARS); + return token_t(token_t::TOK_YEARS); else if (term == _("quarters")) - return token_t(token_t::TOK_QUARTERS); + return token_t(token_t::TOK_QUARTERS); else if (term == _("months")) - return token_t(token_t::TOK_MONTHS); + return token_t(token_t::TOK_MONTHS); else if (term == _("weeks")) - return token_t(token_t::TOK_WEEKS); + return token_t(token_t::TOK_WEEKS); else if (term == _("days")) - return token_t(token_t::TOK_DAYS); + return token_t(token_t::TOK_DAYS); } else { token_t::expected('\0', term[0]); @@ -1462,12 +1462,12 @@ namespace { typedef std::map<std::string, date_io_t *> date_io_map; datetime_io_map temp_datetime_io; - date_io_map temp_date_io; + date_io_map temp_date_io; } -std::string format_datetime(const datetime_t& when, - const format_type_t format_type, - const optional<const char *>& format) +std::string format_datetime(const datetime_t& when, + const format_type_t format_type, + const optional<const char *>& format) { if (format_type == FMT_WRITTEN) { return written_datetime_io->format(when); @@ -1491,9 +1491,9 @@ std::string format_datetime(const datetime_t& when, } } -std::string format_date(const date_t& when, - const format_type_t format_type, - const optional<const char *>& format) +std::string format_date(const date_t& when, + const format_type_t format_type, + const optional<const char *>& format) { if (format_type == FMT_WRITTEN) { return written_date_io->format(when); diff --git a/src/times.h b/src/times.h index 51cc8491..02b39ef7 100644 --- a/src/times.h +++ b/src/times.h @@ -51,8 +51,8 @@ namespace ledger { DECLARE_EXCEPTION(datetime_error, std::runtime_error); DECLARE_EXCEPTION(date_error, std::runtime_error); -typedef boost::posix_time::ptime datetime_t; -typedef datetime_t::time_duration_type time_duration_t; +typedef boost::posix_time::ptime datetime_t; +typedef datetime_t::time_duration_type time_duration_t; inline bool is_valid(const datetime_t& moment) { return ! moment.is_not_a_date_time(); @@ -89,14 +89,14 @@ typedef optional<date_t::year_type> optional_year; datetime_t parse_datetime(const char * str, optional_year current_year = none); inline datetime_t parse_datetime(const std::string& str, - optional_year current_year = none) { + optional_year current_year = none) { return parse_datetime(str.c_str(), current_year); } date_t parse_date(const char * str, optional_year current_year = none); inline date_t parse_date(const std::string& str, - optional_year current_year = none) { + optional_year current_year = none) { return parse_date(str.c_str(), current_year); } @@ -105,18 +105,18 @@ enum format_type_t { }; std::string format_datetime(const datetime_t& when, - const format_type_t format_type = FMT_PRINTED, - const optional<const char *>& format = none); + const format_type_t format_type = FMT_PRINTED, + const optional<const char *>& format = none); void set_datetime_format(const char * format); std::string format_date(const date_t& when, - const format_type_t format_type = FMT_PRINTED, - const optional<const char *>& format = none); + const format_type_t format_type = FMT_PRINTED, + const optional<const char *>& format = none); void set_date_format(const char * format); void set_input_date_format(const char * format); inline void to_xml(std::ostream& out, const datetime_t& when, - bool wrap = true) + bool wrap = true) { if (wrap) { push_xml x(out, "datetime"); @@ -127,7 +127,7 @@ inline void to_xml(std::ostream& out, const datetime_t& when, } inline void to_xml(std::ostream& out, const date_t& when, - bool wrap = true) + bool wrap = true) { if (wrap) { push_xml x(out, "date"); @@ -144,8 +144,8 @@ struct date_traits_t bool has_day; date_traits_t(bool _has_year = false, - bool _has_month = false, - bool _has_day = false) + bool _has_month = false, + bool _has_day = false) : has_year(_has_year), has_month(_has_month), has_day(_has_day) { TRACE_CTOR(date_traits_t, "bool, bool, bool"); } @@ -160,16 +160,16 @@ struct date_traits_t } date_traits_t& operator=(const date_traits_t& traits) { - has_year = traits.has_year; + has_year = traits.has_year; has_month = traits.has_month; - has_day = traits.has_day; + has_day = traits.has_day; return *this; } bool operator==(const date_traits_t& traits) const { - return (has_year == traits.has_year && - has_month == traits.has_month && - has_day == traits.has_day); + return (has_year == traits.has_year && + has_month == traits.has_month && + has_day == traits.has_day); } #if defined(HAVE_BOOST_SERIALIZATION) @@ -249,11 +249,11 @@ struct date_duration_t out << length << ' '; switch (quantum) { - case DAYS: out << "day"; break; - case WEEKS: out << "week"; break; + case DAYS: out << "day"; break; + case WEEKS: out << "week"; break; case MONTHS: out << "month"; break; case QUARTERS: out << "quarter"; break; - case YEARS: out << "year"; break; + case YEARS: out << "year"; break; default: assert(false); break; @@ -287,31 +287,31 @@ class date_specifier_t public: #if 0 - typedef date_t::year_type year_type; + typedef date_t::year_type year_type; #else - typedef unsigned short year_type; + typedef unsigned short year_type; #endif - typedef date_t::month_type month_type; - typedef date_t::day_type day_type; + typedef date_t::month_type month_type; + typedef date_t::day_type day_type; typedef date_t::day_of_week_type day_of_week_type; protected: - optional<year_type> year; - optional<month_type> month; - optional<day_type> day; + optional<year_type> year; + optional<month_type> month; + optional<day_type> day; optional<day_of_week_type> wday; public: date_specifier_t(const optional<year_type>& _year = none, - const optional<month_type>& _month = none, - const optional<day_type>& _day = none, - const optional<day_of_week_type>& _wday = none) + const optional<month_type>& _month = none, + const optional<day_type>& _day = none, + const optional<day_of_week_type>& _wday = none) : year(_year), month(_month), day(_day), wday(_wday) { TRACE_CTOR(date_specifier_t, - "year_type, month_type, day_type, day_of_week_type"); + "year_type, month_type, day_type, day_of_week_type"); } date_specifier_t(const date_t& date, - const optional<date_traits_t>& traits = none) { + const optional<date_traits_t>& traits = none) { TRACE_CTOR(date_specifier_t, "date_t, date_traits_t"); if (! traits || traits->has_year) year = date.year(); @@ -333,7 +333,7 @@ public: date_t end(const optional_year& current_year = none) const; bool is_within(const date_t& date, - const optional_year& current_year = none) const { + const optional_year& current_year = none) const { return date >= begin(current_year) && date < end(current_year); } @@ -390,7 +390,7 @@ class date_range_t public: date_range_t(const optional<date_specifier_t>& _range_begin = none, - const optional<date_specifier_t>& _range_end = none) + const optional<date_specifier_t>& _range_end = none) : range_begin(_range_begin), range_end(_range_end), end_inclusive(false) { TRACE_CTOR(date_range_t, "date_specifier_t, date_specifier_t"); @@ -413,16 +413,16 @@ public: optional<date_t> end(const optional_year& current_year = none) const { if (range_end) { if (end_inclusive) - return range_end->end(current_year); + return range_end->end(current_year); else - return range_end->begin(current_year); + return range_end->begin(current_year); } else { return none; } } bool is_within(const date_t& date, - const optional_year& current_year = none) const { + const optional_year& current_year = none) const { optional<date_t> b = begin(current_year); optional<date_t> e = end(current_year); bool after_begin = b ? date >= *b : true; @@ -527,19 +527,19 @@ private: class date_interval_t : public equality_comparable<date_interval_t> { public: - static date_t add_duration(const date_t& date, - const date_duration_t& duration); - static date_t subtract_duration(const date_t& date, - const date_duration_t& duration); + static date_t add_duration(const date_t& date, + const date_duration_t& duration); + static date_t subtract_duration(const date_t& date, + const date_duration_t& duration); optional<date_specifier_or_range_t> range; - optional<date_t> start; // the real start, after adjustment - optional<date_t> finish; // the real end, likewise - bool aligned; - optional<date_t> next; + optional<date_t> start; // the real start, after adjustment + optional<date_t> finish; // the real end, likewise + bool aligned; + optional<date_t> next; optional<date_duration_t> duration; - optional<date_t> end_of_duration; + optional<date_t> end_of_duration; explicit date_interval_t() : aligned(false) { TRACE_CTOR(date_interval_t, ""); @@ -564,7 +564,7 @@ public: bool operator==(const date_interval_t& other) const { return (start == other.start && - (! start || *start == *other.start)); + (! start || *start == *other.start)); } operator bool() const { @@ -580,8 +580,8 @@ public: void parse(const string& str); - void resolve_end(); - void stabilize(const optional<date_t>& date = none); + void resolve_end(); + void stabilize(const optional<date_t>& date = none); bool is_valid() const { return start; diff --git a/src/token.cc b/src/token.cc index 905e13fe..9dfff065 100644 --- a/src/token.cc +++ b/src/token.cc @@ -50,74 +50,74 @@ int expr_t::token_t::parse_reserved_word(std::istream& in) switch (buf[0]) { case 'a': if (std::strcmp(buf, "and") == 0) { - symbol[0] = '&'; - symbol[1] = '\0'; - kind = KW_AND; - return 1; + symbol[0] = '&'; + symbol[1] = '\0'; + kind = KW_AND; + return 1; } break; case 'd': if (std::strcmp(buf, "div") == 0) { - symbol[0] = '/'; - symbol[1] = '/'; - symbol[2] = '\0'; - kind = KW_DIV; - return 1; + symbol[0] = '/'; + symbol[1] = '/'; + symbol[2] = '\0'; + kind = KW_DIV; + return 1; } break; case 'e': if (std::strcmp(buf, "else") == 0) { - symbol[0] = 'L'; - symbol[1] = 'S'; - symbol[2] = '\0'; - kind = KW_ELSE; - return 1; + symbol[0] = 'L'; + symbol[1] = 'S'; + symbol[2] = '\0'; + kind = KW_ELSE; + return 1; } break; case 'f': if (std::strcmp(buf, "false") == 0) { - kind = VALUE; - value = false; - return 1; + kind = VALUE; + value = false; + return 1; } break; case 'i': if (std::strcmp(buf, "if") == 0) { - symbol[0] = 'i'; - symbol[1] = 'f'; - symbol[2] = '\0'; - kind = KW_IF; - return 1; + symbol[0] = 'i'; + symbol[1] = 'f'; + symbol[2] = '\0'; + kind = KW_IF; + return 1; } break; case 'o': if (std::strcmp(buf, "or") == 0) { - symbol[0] = '|'; - symbol[1] = '\0'; - kind = KW_OR; - return 1; + symbol[0] = '|'; + symbol[1] = '\0'; + kind = KW_OR; + return 1; } break; case 'n': if (std::strcmp(buf, "not") == 0) { - symbol[0] = '!'; - symbol[1] = '\0'; - kind = EXCLAM; - return 1; + symbol[0] = '!'; + symbol[1] = '\0'; + kind = EXCLAM; + return 1; } break; case 't': if (std::strcmp(buf, "true") == 0) { - kind = VALUE; - value = true; - return 1; + kind = VALUE; + value = true; + return 1; } break; } @@ -129,7 +129,7 @@ int expr_t::token_t::parse_reserved_word(std::istream& in) void expr_t::token_t::parse_ident(std::istream& in) { - kind = IDENT; + kind = IDENT; length = 0; char c, buf[256]; @@ -139,7 +139,7 @@ void expr_t::token_t::parse_ident(std::istream& in) } void expr_t::token_t::next(std::istream& in, const parse_flags_t& pflags, - const char expecting) + const char expecting) { if (in.eof()) { kind = TOK_EOF; @@ -210,7 +210,7 @@ void expr_t::token_t::next(std::istream& in, const parse_flags_t& pflags, optional<date_t> begin = timespan.begin(); if (! begin) throw_(parse_error, - _("Date specifier does not refer to a starting date")); + _("Date specifier does not refer to a starting date")); kind = VALUE; value = *begin; break; @@ -302,12 +302,12 @@ void expr_t::token_t::next(std::istream& in, const parse_flags_t& pflags, in.get(c); if (pflags.has_flags(PARSE_OP_CONTEXT)) { // operator context kind = SLASH; - } else { // terminal context + } else { // terminal context // Read in the regexp char buf[256]; READ_INTO_(in, buf, 255, c, length, c != '/'); if (c != '/') - expected('/', c); + expected('/', c); in.get(c); length++; @@ -395,7 +395,7 @@ void expr_t::token_t::next(std::istream& in, const parse_flags_t& pflags, in.clear(); in.seekg(pos, std::ios::beg); if (in.fail()) - throw_(parse_error, _("Failed to reset input stream")); + throw_(parse_error, _("Failed to reset input stream")); } // When in relaxed parsing mode, we want to migrate commodity flags @@ -411,30 +411,30 @@ void expr_t::token_t::next(std::istream& in, const parse_flags_t& pflags, try { amount_t temp; if (! temp.parse(in, parse_flags.plus_flags(PARSE_SOFT_FAIL))) { - // If the amount had no commodity, it must be an unambiguous - // variable reference - - in.clear(); - in.seekg(pos, std::ios::beg); - if (in.fail()) - throw_(parse_error, _("Failed to reset input stream")); - - c = static_cast<char>(in.peek()); - if (std::isdigit(c) || c == '.') - expected('\0', c); - - parse_ident(in); - - if (value.as_string().length() == 0) { - kind = ERROR; - symbol[0] = c; - symbol[1] = '\0'; - unexpected(expecting); - } + // If the amount had no commodity, it must be an unambiguous + // variable reference + + in.clear(); + in.seekg(pos, std::ios::beg); + if (in.fail()) + throw_(parse_error, _("Failed to reset input stream")); + + c = static_cast<char>(in.peek()); + if (std::isdigit(c) || c == '.') + expected('\0', c); + + parse_ident(in); + + if (value.as_string().length() == 0) { + kind = ERROR; + symbol[0] = c; + symbol[1] = '\0'; + unexpected(expecting); + } } else { - kind = VALUE; - value = temp; - length = static_cast<std::size_t>(in.tellg() - pos); + kind = VALUE; + value = temp; + length = static_cast<std::size_t>(in.tellg() - pos); } } catch (const std::exception& err) { @@ -476,16 +476,16 @@ void expr_t::token_t::unexpected(const char wanted) switch (prev_kind) { case TOK_EOF: throw_(parse_error, - _("Unexpected end of expression (wanted '%1')") << wanted); + _("Unexpected end of expression (wanted '%1')") << wanted); case IDENT: throw_(parse_error, - _("Unexpected symbol '%1' (wanted '%2')") << value << wanted); + _("Unexpected symbol '%1' (wanted '%2')") << value << wanted); case VALUE: throw_(parse_error, - _("Unexpected value '%1' (wanted '%2')") << value << wanted); + _("Unexpected value '%1' (wanted '%2')") << value << wanted); default: throw_(parse_error, _("Unexpected expression token '%1' (wanted '%2')") - << symbol << wanted); + << symbol << wanted); } } } diff --git a/src/token.h b/src/token.h index 582373cb..aae73837 100644 --- a/src/token.h +++ b/src/token.h @@ -49,52 +49,52 @@ namespace ledger { struct expr_t::token_t : public noncopyable { enum kind_t { - ERROR, // an error occurred while tokenizing - VALUE, // any kind of literal value - IDENT, // [A-Za-z_][-A-Za-z0-9_:]* - MASK, // /regexp/ - - LPAREN, // ( - RPAREN, // ) - - EQUAL, // == - NEQUAL, // != - LESS, // < - LESSEQ, // <= - GREATER, // > - GREATEREQ, // >= - - DEFINE, // := - ASSIGN, // = - MATCH, // =~ - NMATCH, // !~ - MINUS, // - - PLUS, // + - STAR, // * - SLASH, // / - KW_DIV, // div - - EXCLAM, // !, not - KW_AND, // &, &&, and - KW_OR, // |, ||, or - KW_MOD, // % - - KW_IF, // if - KW_ELSE, // else - - QUERY, // ? - COLON, // : - - DOT, // . - COMMA, // , - SEMI, // ; + ERROR, // an error occurred while tokenizing + VALUE, // any kind of literal value + IDENT, // [A-Za-z_][-A-Za-z0-9_:]* + MASK, // /regexp/ + + LPAREN, // ( + RPAREN, // ) + + EQUAL, // == + NEQUAL, // != + LESS, // < + LESSEQ, // <= + GREATER, // > + GREATEREQ, // >= + + DEFINE, // := + ASSIGN, // = + MATCH, // =~ + NMATCH, // !~ + MINUS, // - + PLUS, // + + STAR, // * + SLASH, // / + KW_DIV, // div + + EXCLAM, // !, not + KW_AND, // &, &&, and + KW_OR, // |, ||, or + KW_MOD, // % + + KW_IF, // if + KW_ELSE, // else + + QUERY, // ? + COLON, // : + + DOT, // . + COMMA, // , + SEMI, // ; TOK_EOF, UNKNOWN } kind; - char symbol[3]; + char symbol[3]; value_t value; std::size_t length; @@ -108,7 +108,7 @@ struct expr_t::token_t : public noncopyable token_t& operator=(const token_t& other) { if (&other == this) return *this; - assert(false); // only one token object is used at a time + assert(false); // only one token object is used at a time return *this; } @@ -125,7 +125,7 @@ struct expr_t::token_t : public noncopyable int parse_reserved_word(std::istream& in); void parse_ident(std::istream& in); void next(std::istream& in, const parse_flags_t& flags, - const char expecting = '\0'); + const char expecting = '\0'); void rewind(std::istream& in); void unexpected(const char wanted = '\0'); void expected(const char wanted, char c = '\0'); diff --git a/src/unistring.h b/src/unistring.h index d42f2b28..979ce08b 100644 --- a/src/unistring.h +++ b/src/unistring.h @@ -67,7 +67,7 @@ public: TRACE_CTOR(unistring, "std::string"); const char * p = input.c_str(); - std::size_t len = input.length(); + std::size_t len = input.length(); VERIFY(utf8::is_valid(p, p + len)); utf8::unchecked::utf8to32(p, p + len, std::back_inserter(utf32chars)); @@ -81,9 +81,9 @@ public: } std::string extract(const std::string::size_type begin = 0, - const std::string::size_type len = 0) const + const std::string::size_type len = 0) const { - std::string utf8result; + std::string utf8result; std::string::size_type this_len = length(); assert(begin <= this_len); @@ -91,10 +91,10 @@ public: if (this_len) utf8::unchecked::utf32to8 - (utf32chars.begin() + begin, - utf32chars.begin() + begin + - (len ? (len > this_len ? this_len : len) : this_len), - std::back_inserter(utf8result)); + (utf32chars.begin() + begin, + utf32chars.begin() + begin + + (len ? (len > this_len ? this_len : len) : this_len), + std::back_inserter(utf8result)); return utf8result; } @@ -103,7 +103,7 @@ public: std::size_t idx = 0; foreach (const boost::uint32_t& ch, utf32chars) { if (idx >= __pos && ch == __s) - return idx; + return idx; idx++; } return npos; @@ -118,10 +118,10 @@ public: }; inline void justify(std::ostream& out, - const std::string& str, - int width, - bool right = false, - bool redden = false) + const std::string& str, + int width, + bool right = false, + bool redden = false) { if (! right) { if (redden) out << "\033[31m"; diff --git a/src/utils.cc b/src/utils.cc index b8acb3db..dce804ff 100644 --- a/src/utils.cc +++ b/src/utils.cc @@ -45,9 +45,9 @@ namespace ledger { DECLARE_EXCEPTION(assertion_failed, std::logic_error); void debug_assert(const string& reason, - const string& func, - const string& file, - std::size_t line) + const string& func, + const string& file, + std::size_t line) { std::ostringstream buf; buf << "Assertion failed in \"" << file << "\", line " << line @@ -80,11 +80,11 @@ typedef std::map<std::string, count_size_pair> object_count_map; namespace { bool memory_tracing_active = false; - memory_map * live_memory = NULL; - memory_map * freed_memory = NULL; + memory_map * live_memory = NULL; + memory_map * freed_memory = NULL; object_count_map * live_memory_count = NULL; object_count_map * total_memory_count = NULL; - objects_map * live_objects = NULL; + objects_map * live_objects = NULL; object_count_map * live_object_count = NULL; object_count_map * total_object_count = NULL; object_count_map * total_ctor_count = NULL; @@ -94,11 +94,11 @@ void initialize_memory_tracing() { memory_tracing_active = false; - live_memory = new memory_map; - freed_memory = new memory_map; + live_memory = new memory_map; + freed_memory = new memory_map; live_memory_count = new object_count_map; total_memory_count = new object_count_map; - live_objects = new objects_map; + live_objects = new objects_map; live_object_count = new object_count_map; total_object_count = new object_count_map; total_ctor_count = new object_count_map; @@ -119,18 +119,18 @@ void shutdown_memory_tracing() report_memory(std::cerr); } - checked_delete(live_memory); live_memory = NULL; - checked_delete(freed_memory); freed_memory = NULL; - checked_delete(live_memory_count); live_memory_count = NULL; + checked_delete(live_memory); live_memory = NULL; + checked_delete(freed_memory); freed_memory = NULL; + checked_delete(live_memory_count); live_memory_count = NULL; checked_delete(total_memory_count); total_memory_count = NULL; - checked_delete(live_objects); live_objects = NULL; - checked_delete(live_object_count); live_object_count = NULL; + checked_delete(live_objects); live_objects = NULL; + checked_delete(live_object_count); live_object_count = NULL; checked_delete(total_object_count); total_object_count = NULL; - checked_delete(total_ctor_count); total_ctor_count = NULL; + checked_delete(total_ctor_count); total_ctor_count = NULL; } inline void add_to_count_map(object_count_map& the_map, - const char * name, std::size_t size) + const char * name, std::size_t size) { object_count_map::iterator k = the_map.find(name); if (k != the_map.end()) { @@ -274,9 +274,9 @@ inline void report_count_map(std::ostream& out, object_count_map& the_map) { foreach (object_count_map::value_type& pair, the_map) out << " " << std::right << std::setw(12) << pair.second.first - << " " << std::right << std::setw(7) << pair.second.second - << " " << std::left << pair.first - << std::endl; + << " " << std::right << std::setw(7) << pair.second.second + << " " << std::left << pair.first + << std::endl; } std::size_t current_objects_size() @@ -290,7 +290,7 @@ std::size_t current_objects_size() } void trace_ctor_func(void * ptr, const char * cls_name, const char * args, - std::size_t cls_size) + std::size_t cls_size) { if (! live_objects || ! memory_tracing_active) return; @@ -358,7 +358,7 @@ void report_memory(std::ostream& out, bool report_all) if (live_memory_count->size() > 0) { out << "NOTE: There may be memory held by Boost " - << "and libstdc++ after ledger::shutdown()" << std::endl; + << "and libstdc++ after ledger::shutdown()" << std::endl; out << "Live memory count:" << std::endl; report_count_map(out, *live_memory_count); } @@ -368,9 +368,9 @@ void report_memory(std::ostream& out, bool report_all) foreach (const memory_map::value_type& pair, *live_memory) out << " " << std::right << std::setw(12) << pair.first - << " " << std::right << std::setw(7) << pair.second.second - << " " << std::left << pair.second.first - << std::endl; + << " " << std::right << std::setw(7) << pair.second.second + << " " << std::left << pair.second.first + << std::endl; } if (report_all && total_memory_count->size() > 0) { @@ -388,9 +388,9 @@ void report_memory(std::ostream& out, bool report_all) foreach (const objects_map::value_type& pair, *live_objects) out << " " << std::right << std::setw(12) << pair.first - << " " << std::right << std::setw(7) << pair.second.second - << " " << std::left << pair.second.first - << std::endl; + << " " << std::right << std::setw(7) << pair.second.second + << " " << std::left << pair.second.first + << std::endl; } if (report_all) { @@ -470,28 +470,28 @@ strings_list split_arguments(const char * line) for (const char * p = line; *p; p++) { if (! in_quoted_string && std::isspace(*p)) { if (q != buf) { - *q = '\0'; - args.push_back(buf); - q = buf; + *q = '\0'; + args.push_back(buf); + q = buf; } } else if (in_quoted_string != '\'' && *p == '\\') { p++; if (! *p) - throw_(std::logic_error, _("Invalid use of backslash")); + throw_(std::logic_error, _("Invalid use of backslash")); *q++ = *p; } else if (in_quoted_string != '"' && *p == '\'') { if (in_quoted_string == '\'') - in_quoted_string = '\0'; + in_quoted_string = '\0'; else - in_quoted_string = '\''; + in_quoted_string = '\''; } else if (in_quoted_string != '\'' && *p == '"') { if (in_quoted_string == '"') - in_quoted_string = '\0'; + in_quoted_string = '\0'; else - in_quoted_string = '"'; + in_quoted_string = '"'; } else { *q++ = *p; @@ -500,7 +500,7 @@ strings_list split_arguments(const char * line) if (in_quoted_string) throw_(std::logic_error, - _("Unterminated string, expected '%1'") << in_quoted_string); + _("Unterminated string, expected '%1'") << in_quoted_string); if (q != buf) { *q = '\0'; @@ -521,12 +521,12 @@ strings_list split_arguments(const char * line) namespace ledger { -log_level_t _log_level = LOG_WARN; -std::ostream * _log_stream = &std::cerr; +log_level_t _log_level = LOG_WARN; +std::ostream * _log_stream = &std::cerr; std::ostringstream _log_buffer; #if defined(TRACING_ON) -uint8_t _trace_level; +uint8_t _trace_level; #endif static inline void stream_memory_size(std::ostream& out, std::size_t size) @@ -560,8 +560,8 @@ bool logger_func(log_level_t level) } *_log_stream << std::right << std::setw(5) - << (TRUE_CURRENT_TIME() - - logger_start).total_milliseconds() << "ms"; + << (TRUE_CURRENT_TIME() - + logger_start).total_milliseconds() << "ms"; #if defined(VERIFY_ON) IF_VERIFY() { @@ -633,11 +633,11 @@ namespace ledger { struct timer_t { - log_level_t level; - ptime begin; - time_duration spent; - std::string description; - bool active; + log_level_t level; + ptime begin; + time_duration spent; + std::string description; + bool active; timer_t(log_level_t _level, std::string _description) : level(_level), begin(TRUE_CURRENT_TIME()), @@ -769,7 +769,7 @@ path expand_path(const path& pathname) return pathname; std::string path_string = pathname.string(); - const char * pfx = NULL; + const char * pfx = NULL; string::size_type pos = path_string.find_first_of('/'); if (path_string.length() == 1 || pos == 1) { @@ -779,14 +779,14 @@ path expand_path(const path& pathname) // Punt. We're trying to expand ~/, but HOME isn't set struct passwd * pw = getpwuid(getuid()); if (pw) - pfx = pw->pw_dir; + pfx = pw->pw_dir; } #endif } #ifdef HAVE_GETPWNAM else { string user(path_string, 1, pos == string::npos ? - string::npos : pos - 1); + string::npos : pos - 1); struct passwd * pw = getpwnam(user.c_str()); if (pw) pfx = pw->pw_dir; diff --git a/src/utils.h b/src/utils.h index 9135abde..40fa57cc 100644 --- a/src/utils.h +++ b/src/utils.h @@ -59,7 +59,7 @@ #define NO_ASSERTS 1 //#define NO_LOGGING 1 #else -#define TRACING_ON 1 // use --trace X to enable +#define TRACING_ON 1 // use --trace X to enable #endif /*@}*/ @@ -80,15 +80,15 @@ namespace ledger { typedef std::list<string> strings_list; - typedef posix_time::ptime ptime; + typedef posix_time::ptime ptime; typedef ptime::time_duration_type time_duration; - typedef gregorian::date date; + typedef gregorian::date date; typedef gregorian::date_duration date_duration; - typedef posix_time::seconds seconds; + typedef posix_time::seconds seconds; - typedef boost::filesystem::path path; - typedef boost::filesystem::ifstream ifstream; - typedef boost::filesystem::ofstream ofstream; + typedef boost::filesystem::path path; + typedef boost::filesystem::ifstream ifstream; + typedef boost::filesystem::ofstream ofstream; typedef boost::filesystem::filesystem_error filesystem_error; } @@ -110,12 +110,12 @@ namespace ledger { namespace ledger { void debug_assert(const string& reason, const string& func, - const string& file, std::size_t line); + const string& file, std::size_t line); } -#define assert(x) \ - ((x) ? ((void)0) : debug_assert(#x, BOOST_CURRENT_FUNCTION, \ - __FILE__, __LINE__)) +#define assert(x) \ + ((x) ? ((void)0) : debug_assert(#x, BOOST_CURRENT_FUNCTION, \ + __FILE__, __LINE__)) #else // ! ASSERTS_ON @@ -146,7 +146,7 @@ std::size_t current_memory_size(); std::size_t current_objects_size(); void trace_ctor_func(void * ptr, const char * cls_name, const char * args, - std::size_t cls_size); + std::size_t cls_size); void trace_dtor_func(void * ptr, const char * cls_name, std::size_t cls_size); #define TRACE_CTOR(cls, args) \ @@ -239,8 +239,8 @@ inline string operator+(const string& __lhs, const char* __rhs) inline string operator+(const string& __lhs, char __rhs) { - typedef string __string_type; - typedef string::size_type __size_type; + typedef string __string_type; + typedef string::size_type __size_type; __string_type __str(__lhs); __str.append(__size_type(1), __rhs); return __str; @@ -301,8 +301,8 @@ enum log_level_t { LOG_ALL }; -extern log_level_t _log_level; -extern std::ostream * _log_stream; +extern log_level_t _log_level; +extern std::ostream * _log_stream; extern std::ostringstream _log_buffer; bool logger_func(log_level_t level); @@ -539,7 +539,7 @@ extern "C" char * realpath(const char *, char resolved_path[]); #endif inline const string& either_or(const string& first, - const string& second) { + const string& second) { return first.empty() ? second : first; } @@ -587,62 +587,62 @@ inline char peek_next_nonws(std::istream& in) { return c; } -#define READ_INTO(str, targ, size, var, cond) { \ - char * _p = targ; \ - var = static_cast<char>(str.peek()); \ - while (str.good() && ! str.eof() && var != '\n' && \ - (cond) && _p - targ < size) { \ - str.get(var); \ - if (str.eof()) \ - break; \ - if (var == '\\') { \ - str.get(var); \ - if (in.eof()) \ - break; \ - switch (var) { \ - case 'b': var = '\b'; break; \ - case 'f': var = '\f'; break; \ - case 'n': var = '\n'; break; \ - case 'r': var = '\r'; break; \ - case 't': var = '\t'; break; \ - case 'v': var = '\v'; break; \ - default: break; \ - } \ - } \ - *_p++ = var; \ - var = static_cast<char>(str.peek()); \ - } \ - *_p = '\0'; \ +#define READ_INTO(str, targ, size, var, cond) { \ + char * _p = targ; \ + var = static_cast<char>(str.peek()); \ + while (str.good() && ! str.eof() && var != '\n' && \ + (cond) && _p - targ < size) { \ + str.get(var); \ + if (str.eof()) \ + break; \ + if (var == '\\') { \ + str.get(var); \ + if (in.eof()) \ + break; \ + switch (var) { \ + case 'b': var = '\b'; break; \ + case 'f': var = '\f'; break; \ + case 'n': var = '\n'; break; \ + case 'r': var = '\r'; break; \ + case 't': var = '\t'; break; \ + case 'v': var = '\v'; break; \ + default: break; \ + } \ + } \ + *_p++ = var; \ + var = static_cast<char>(str.peek()); \ + } \ + *_p = '\0'; \ } -#define READ_INTO_(str, targ, size, var, idx, cond) { \ - char * _p = targ; \ - var = static_cast<char>(str.peek()); \ - while (str.good() && ! str.eof() && var != '\n' && \ - (cond) && _p - targ < size) { \ - str.get(var); \ - if (str.eof()) \ - break; \ - idx++; \ - if (var == '\\') { \ - str.get(var); \ - if (in.eof()) \ - break; \ - switch (var) { \ - case 'b': var = '\b'; break; \ - case 'f': var = '\f'; break; \ - case 'n': var = '\n'; break; \ - case 'r': var = '\r'; break; \ - case 't': var = '\t'; break; \ - case 'v': var = '\v'; break; \ - default: break; \ - } \ - idx++; \ - } \ - *_p++ = var; \ - var = static_cast<char>(str.peek()); \ - } \ - *_p = '\0'; \ +#define READ_INTO_(str, targ, size, var, idx, cond) { \ + char * _p = targ; \ + var = static_cast<char>(str.peek()); \ + while (str.good() && ! str.eof() && var != '\n' && \ + (cond) && _p - targ < size) { \ + str.get(var); \ + if (str.eof()) \ + break; \ + idx++; \ + if (var == '\\') { \ + str.get(var); \ + if (in.eof()) \ + break; \ + switch (var) { \ + case 'b': var = '\b'; break; \ + case 'f': var = '\f'; break; \ + case 'n': var = '\n'; break; \ + case 'r': var = '\r'; break; \ + case 't': var = '\t'; break; \ + case 'v': var = '\v'; break; \ + default: break; \ + } \ + idx++; \ + } \ + *_p++ = var; \ + var = static_cast<char>(str.peek()); \ + } \ + *_p = '\0'; \ } inline string to_hex(uint_least32_t * message_digest, const int len = 1) @@ -654,7 +654,7 @@ inline string to_hex(uint_least32_t * message_digest, const int len = 1) buf.fill('0'); buf << std::hex << message_digest[i]; if (i + 1 >= len) - break; // only output the first LEN dwords + break; // only output the first LEN dwords } return buf.str(); } @@ -672,12 +672,12 @@ inline string sha1sum(const string& str) class push_xml { std::ostream& out; - string tag; - bool leave_open; + string tag; + bool leave_open; public: push_xml(std::ostream& _out, const string& _tag, bool has_attrs = false, - bool _leave_open = false) + bool _leave_open = false) : out(_out), tag(_tag), leave_open(_leave_open) { out << '<' << tag; if (! has_attrs) @@ -697,17 +697,17 @@ public: foreach (const char& ch, str) { switch (ch) { case '<': - buf << "<"; - break; + buf << "<"; + break; case '>': - buf << ">"; - break; + buf << ">"; + break; case '&': - buf << "&"; - break; + buf << "&"; + break; default: - buf << ch; - break; + buf << ch; + break; } } return buf.str(); diff --git a/src/value.cc b/src/value.cc index 74dd843d..63e48333 100644 --- a/src/value.cc +++ b/src/value.cc @@ -35,7 +35,7 @@ #include "commodity.h" #include "annotate.h" #include "pool.h" -#include "unistring.h" // for justify() +#include "unistring.h" // for justify() #include "op.h" namespace ledger { @@ -65,11 +65,11 @@ value_t::storage_t& value_t::storage_t::operator=(const value_t::storage_t& rhs) void value_t::initialize() { - true_value = new storage_t; + true_value = new storage_t; true_value->type = BOOLEAN; true_value->data = true; - false_value = new storage_t; + false_value = new storage_t; false_value->type = BOOLEAN; false_value->data = false; } @@ -103,14 +103,14 @@ value_t::operator bool() const std::ostringstream out; out << *this; throw_(value_error, - _("Cannot determine truth of %1 (did you mean 'account =~ %2'?)") - << label() << out.str()); + _("Cannot determine truth of %1 (did you mean 'account =~ %2'?)") + << label() << out.str()); } case SEQUENCE: if (! as_sequence().empty()) { foreach (const value_t& value, as_sequence()) { - if (value) - return true; + if (value) + return true; } } return false; @@ -281,7 +281,7 @@ void value_t::in_place_simplify() DEBUG_("as an amount it looks like: " << *this); } -#ifdef REDUCE_TO_INTEGER // this is off by default +#ifdef REDUCE_TO_INTEGER // this is off by default if (is_amount() && ! as_amount().has_commodity() && as_amount().fits_in_long()) { DEBUG_("Reducing amount to integer"); @@ -307,7 +307,7 @@ value_t value_t::number() const if (! as_sequence().empty()) { value_t temp; foreach (const value_t& value, as_sequence()) - temp += value.number(); + temp += value.number(); return temp; } break; @@ -333,14 +333,14 @@ value_t& value_t::operator+=(const value_t& val) else if (is_sequence()) { if (val.is_sequence()) { if (size() == val.size()) { - sequence_t::iterator i = begin(); - sequence_t::const_iterator j = val.begin(); + sequence_t::iterator i = begin(); + sequence_t::const_iterator j = val.begin(); - for (; i != end(); i++, j++) - *i += *j; + for (; i != end(); i++, j++) + *i += *j; } else { - add_error_context(_("While adding %1 to %2:") << *this << val); - throw_(value_error, _("Cannot add sequences of different lengths")); + add_error_context(_("While adding %1 to %2:") << *this << val); + throw_(value_error, _("Cannot add sequences of different lengths")); } } else { as_sequence_lval().push_back(new value_t(val)); @@ -353,12 +353,12 @@ value_t& value_t::operator+=(const value_t& val) switch (val.type()) { case INTEGER: as_datetime_lval() += - time_duration_t(0, 0, static_cast<time_duration_t::sec_type>(val.as_long())); + time_duration_t(0, 0, static_cast<time_duration_t::sec_type>(val.as_long())); return *this; case AMOUNT: as_datetime_lval() += - time_duration_t(0, 0, static_cast<time_duration_t::sec_type> - (val.as_amount().to_long())); + time_duration_t(0, 0, static_cast<time_duration_t::sec_type> + (val.as_amount().to_long())); return *this; default: break; @@ -385,8 +385,8 @@ value_t& value_t::operator+=(const value_t& val) return *this; case AMOUNT: if (val.as_amount().has_commodity()) { - in_place_cast(BALANCE); - return *this += val; + in_place_cast(BALANCE); + return *this += val; } in_place_cast(AMOUNT); as_amount_lval() += val.as_amount(); @@ -404,21 +404,21 @@ value_t& value_t::operator+=(const value_t& val) switch (val.type()) { case INTEGER: if (as_amount().has_commodity()) { - in_place_cast(BALANCE); - return *this += val; + in_place_cast(BALANCE); + return *this += val; } else { - as_amount_lval() += val.as_long(); - return *this; + as_amount_lval() += val.as_long(); + return *this; } break; case AMOUNT: if (as_amount().commodity() != val.as_amount().commodity()) { - in_place_cast(BALANCE); - return *this += val; + in_place_cast(BALANCE); + return *this += val; } else { - as_amount_lval() += val.as_amount(); - return *this; + as_amount_lval() += val.as_amount(); + return *this; } break; @@ -465,19 +465,19 @@ value_t& value_t::operator-=(const value_t& val) if (val.is_sequence()) { if (size() == val.size()) { - sequence_t::iterator i = begin(); - sequence_t::const_iterator j = val.begin(); + sequence_t::iterator i = begin(); + sequence_t::const_iterator j = val.begin(); - for (; i != end(); i++, j++) - *i -= *j; + for (; i != end(); i++, j++) + *i -= *j; } else { - add_error_context(_("While subtracting %1 to %2:") << *this << val); - throw_(value_error, _("Cannot subtract sequences of different lengths")); + add_error_context(_("While subtracting %1 to %2:") << *this << val); + throw_(value_error, _("Cannot subtract sequences of different lengths")); } } else { sequence_t::iterator i = std::find(seq.begin(), seq.end(), val); if (i != seq.end()) - seq.erase(i); + seq.erase(i); } return *this; } @@ -487,12 +487,12 @@ value_t& value_t::operator-=(const value_t& val) switch (val.type()) { case INTEGER: as_datetime_lval() -= - time_duration_t(0, 0, static_cast<time_duration_t::sec_type>(val.as_long())); + time_duration_t(0, 0, static_cast<time_duration_t::sec_type>(val.as_long())); return *this; case AMOUNT: as_datetime_lval() -= - time_duration_t(0, 0, static_cast<time_duration_t::sec_type> - (val.as_amount().to_long())); + time_duration_t(0, 0, static_cast<time_duration_t::sec_type> + (val.as_amount().to_long())); return *this; default: break; @@ -536,27 +536,27 @@ value_t& value_t::operator-=(const value_t& val) switch (val.type()) { case INTEGER: if (as_amount().has_commodity()) { - in_place_cast(BALANCE); - *this -= val; - in_place_simplify(); - return *this; + in_place_cast(BALANCE); + *this -= val; + in_place_simplify(); + return *this; } else { - as_amount_lval() -= val.as_long(); - in_place_simplify(); - return *this; + as_amount_lval() -= val.as_long(); + in_place_simplify(); + return *this; } break; case AMOUNT: if (as_amount().commodity() != val.as_amount().commodity()) { - in_place_cast(BALANCE); - *this -= val; - in_place_simplify(); - return *this; + in_place_cast(BALANCE); + *this -= val; + in_place_simplify(); + return *this; } else { - as_amount_lval() -= val.as_amount(); - in_place_simplify(); - return *this; + as_amount_lval() -= val.as_amount(); + in_place_simplify(); + return *this; } break; @@ -642,8 +642,8 @@ value_t& value_t::operator*=(const value_t& val) return *this; case BALANCE: if (val.as_balance().single_amount()) { - as_amount_lval() *= val.simplified().as_amount(); - return *this; + as_amount_lval() *= val.simplified().as_amount(); + return *this; } break; default: @@ -658,13 +658,13 @@ value_t& value_t::operator*=(const value_t& val) return *this; case AMOUNT: if (as_balance().single_amount()) { - in_place_simplify(); - as_amount_lval() *= val.as_amount(); - return *this; + in_place_simplify(); + as_amount_lval() *= val.as_amount(); + return *this; } else if (! val.as_amount().has_commodity()) { - as_balance_lval() *= val.as_amount(); - return *this; + as_balance_lval() *= val.as_amount(); + return *this; } break; default: @@ -709,19 +709,19 @@ value_t& value_t::operator/=(const value_t& val) return *this; case BALANCE: if (val.as_balance().single_amount()) { - value_t simpler(val.simplified()); - switch (simpler.type()) { - case INTEGER: - as_amount_lval() /= simpler.as_long(); - break; - case AMOUNT: - as_amount_lval() /= simpler.as_amount(); - break; - default: - assert(false); - break; - } - return *this; + value_t simpler(val.simplified()); + switch (simpler.type()) { + case INTEGER: + as_amount_lval() /= simpler.as_long(); + break; + case AMOUNT: + as_amount_lval() /= simpler.as_amount(); + break; + default: + assert(false); + break; + } + return *this; } break; default: @@ -736,13 +736,13 @@ value_t& value_t::operator/=(const value_t& val) return *this; case AMOUNT: if (as_balance().single_amount()) { - in_place_simplify(); - as_amount_lval() /= val.as_amount(); - return *this; + in_place_simplify(); + as_amount_lval() /= val.as_amount(); + return *this; } else if (! val.as_amount().has_commodity()) { - as_balance_lval() /= val.as_amount(); - return *this; + as_balance_lval() /= val.as_amount(); + return *this; } break; default: @@ -852,16 +852,16 @@ bool value_t::is_less_than(const value_t& val) const case BOOLEAN: if (val.is_boolean()) { if (as_boolean()) { - if (! val.as_boolean()) - return false; - else - return false; + if (! val.as_boolean()) + return false; + else + return false; } else if (! as_boolean()) { - if (! val.as_boolean()) - return false; - else - return true; + if (! val.as_boolean()) + return false; + else + return true; } } break; @@ -893,11 +893,11 @@ bool value_t::is_less_than(const value_t& val) const return as_amount() < val.as_long(); case AMOUNT: if (as_amount().commodity() == val.as_amount().commodity() || - ! as_amount().has_commodity() || - ! val.as_amount().has_commodity()) - return as_amount() < val.as_amount(); + ! as_amount().has_commodity() || + ! val.as_amount().has_commodity()) + return as_amount() < val.as_amount(); else - return commodity_t::compare_by_commodity()(&as_amount(), &val.as_amount()); + return commodity_t::compare_by_commodity()(&as_amount(), &val.as_amount()); default: break; } @@ -908,14 +908,14 @@ bool value_t::is_less_than(const value_t& val) const case INTEGER: case AMOUNT: { if (val.is_nonzero()) - break; + break; bool no_amounts = true; foreach (const balance_t::amounts_map::value_type& pair, - as_balance().amounts) { - if (pair.second >= 0L) - return false; - no_amounts = false; + as_balance().amounts) { + if (pair.second >= 0L) + return false; + no_amounts = false; } return ! no_amounts; } @@ -934,13 +934,13 @@ bool value_t::is_less_than(const value_t& val) const case INTEGER: case AMOUNT: { if (val.is_nonzero()) - break; + break; bool no_amounts = true; foreach (const value_t& value, as_sequence()) { - if (value >= 0L) - return false; - no_amounts = false; + if (value >= 0L) + return false; + no_amounts = false; } return ! no_amounts; } @@ -948,14 +948,14 @@ bool value_t::is_less_than(const value_t& val) const sequence_t::const_iterator i = as_sequence().begin(); sequence_t::const_iterator j = val.as_sequence().begin(); for (; (i != as_sequence().end() && - j != val.as_sequence().end()); i++, j++) { - if (! ((*i) < (*j))) - return false; + j != val.as_sequence().end()); i++, j++) { + if (! ((*i) < (*j))) + return false; } if (i == as_sequence().end()) - return true; + return true; else - return false; + return false; break; } default: @@ -968,7 +968,7 @@ bool value_t::is_less_than(const value_t& val) const } add_error_context(_("While comparing if %1 is less than %2:") - << *this << val); + << *this << val); throw_(value_error, _("Cannot compare %1 to %2") << label() << val.label()); return *this; @@ -979,16 +979,16 @@ bool value_t::is_greater_than(const value_t& val) const switch (type()) { if (val.is_boolean()) { if (as_boolean()) { - if (! val.as_boolean()) - return true; - else - return false; + if (! val.as_boolean()) + return true; + else + return false; } else if (! as_boolean()) { - if (! val.as_boolean()) - return false; - else - return false; + if (! val.as_boolean()) + return false; + else + return false; } } break; @@ -1030,14 +1030,14 @@ bool value_t::is_greater_than(const value_t& val) const case INTEGER: case AMOUNT: { if (val.is_nonzero()) - break; + break; bool no_amounts = true; foreach (const balance_t::amounts_map::value_type& pair, - as_balance().amounts) { - if (pair.second <= 0L) - return false; - no_amounts = false; + as_balance().amounts) { + if (pair.second <= 0L) + return false; + no_amounts = false; } return ! no_amounts; } @@ -1056,13 +1056,13 @@ bool value_t::is_greater_than(const value_t& val) const case INTEGER: case AMOUNT: { if (val.is_nonzero()) - break; + break; bool no_amounts = true; foreach (const value_t& value, as_sequence()) { - if (value <= 0L) - return false; - no_amounts = false; + if (value <= 0L) + return false; + no_amounts = false; } return ! no_amounts; } @@ -1070,14 +1070,14 @@ bool value_t::is_greater_than(const value_t& val) const sequence_t::const_iterator i = as_sequence().begin(); sequence_t::const_iterator j = val.as_sequence().begin(); for (; (i != as_sequence().end() && - j != val.as_sequence().end()); i++, j++) { - if (! ((*i) > (*j))) - return false; + j != val.as_sequence().end()); i++, j++) { + if (! ((*i) > (*j))) + return false; } if (i == as_sequence().end()) - return false; + return false; else - return true; + return true; break; } default: @@ -1090,7 +1090,7 @@ bool value_t::is_greater_than(const value_t& val) const } add_error_context(_("While comparing if %1 is greater than %2:") - << *this << val); + << *this << val); throw_(value_error, _("Cannot compare %1 to %2") << label() << val.label()); return *this; @@ -1194,21 +1194,21 @@ void value_t::in_place_cast(type_t cast_type) switch (cast_type) { case INTEGER: if (amt.is_null()) - set_long(0L); + set_long(0L); else - set_long(as_amount().to_long()); + set_long(as_amount().to_long()); return; case BALANCE: if (amt.is_null()) - set_balance(balance_t()); + set_balance(balance_t()); else - set_balance(as_amount()); + set_balance(as_amount()); return; case STRING: if (amt.is_null()) - set_string(""); + set_string(""); else - set_string(as_amount().to_string()); + set_string(as_amount().to_string()); return; default: break; @@ -1221,28 +1221,28 @@ void value_t::in_place_cast(type_t cast_type) switch (cast_type) { case AMOUNT: { if (bal.amounts.size() == 1) { - // Because we are changing the current balance value to an amount - // value, and because set_amount takes a reference (and that memory is - // about to be repurposed), we must pass in a copy. - set_amount(amount_t((*bal.amounts.begin()).second)); - return; + // Because we are changing the current balance value to an amount + // value, and because set_amount takes a reference (and that memory is + // about to be repurposed), we must pass in a copy. + set_amount(amount_t((*bal.amounts.begin()).second)); + return; } else if (bal.amounts.size() == 0) { - set_amount(0L); - return; + set_amount(0L); + return; } else { - add_error_context(_("While converting %1 to an amount:") << *this); - throw_(value_error, _("Cannot convert %1 with multiple commodities to %2") - << label() << label(cast_type)); + add_error_context(_("While converting %1 to an amount:") << *this); + throw_(value_error, _("Cannot convert %1 with multiple commodities to %2") + << label() << label(cast_type)); } break; } case STRING: if (bal.is_empty()) - set_string(""); + set_string(""); else - set_string(as_balance().to_string()); + set_string(as_balance().to_string()); return; default: break; @@ -1254,8 +1254,8 @@ void value_t::in_place_cast(type_t cast_type) switch (cast_type) { case INTEGER: { if (all(as_string(), is_digit())) { - set_long(lexical_cast<long>(as_string())); - return; + set_long(lexical_cast<long>(as_string())); + return; } break; } @@ -1282,7 +1282,7 @@ void value_t::in_place_cast(type_t cast_type) add_error_context(_("While converting %1:") << *this); throw_(value_error, - _("Cannot convert %1 to %2") << label() << label(cast_type)); + _("Cannot convert %1 to %2") << label() << label(cast_type)); } void value_t::in_place_negate() @@ -1421,7 +1421,7 @@ bool value_t::is_zero() const } value_t value_t::value(const optional<datetime_t>& moment, - const optional<commodity_t&>& in_terms_of) const + const optional<commodity_t&>& in_terms_of) const { switch (type()) { case INTEGER: @@ -1429,13 +1429,13 @@ value_t value_t::value(const optional<datetime_t>& moment, case AMOUNT: if (optional<amount_t> val = - as_amount().value(moment, in_terms_of)) + as_amount().value(moment, in_terms_of)) return *val; return NULL_VALUE; case BALANCE: if (optional<balance_t> bal = - as_balance().value(moment, in_terms_of)) + as_balance().value(moment, in_terms_of)) return *bal; return NULL_VALUE; @@ -1460,9 +1460,9 @@ value_t value_t::price() const } } -value_t value_t::exchange_commodities(const std::string& commodities, - const bool add_prices, - const optional<datetime_t>& moment) +value_t value_t::exchange_commodities(const std::string& commodities, + const bool add_prices, + const optional<datetime_t>& moment) { scoped_array<char> buf(new char[commodities.length() + 1]); @@ -1472,11 +1472,11 @@ value_t value_t::exchange_commodities(const std::string& commodities, p; p = std::strtok(NULL, ",")) { if (commodity_t * commodity = - commodity_pool_t::current_pool->parse_price_expression(p, add_prices, - moment)) { + commodity_pool_t::current_pool->parse_price_expression(p, add_prices, + moment)) { value_t result = value(moment, *commodity); if (! result.is_null()) - return result; + return result; } } return *this; @@ -1657,7 +1657,7 @@ bool value_t::has_annotation() const } else { add_error_context(_("While checking if %1 has annotations:") << *this); throw_(value_error, - _("Cannot determine whether %1 is annotated") << label()); + _("Cannot determine whether %1 is annotated") << label()); } return false; } @@ -1711,9 +1711,9 @@ value_t value_t::strip_annotations(const keep_details_t& what_to_keep) const } void value_t::print(std::ostream& out, - const int first_width, - const int latter_width, - const uint_least8_t flags) const + const int first_width, + const int latter_width, + const uint_least8_t flags) const { if (first_width > 0 && (! is_amount() || as_amount().is_zero()) && @@ -1746,7 +1746,7 @@ void value_t::print(std::ostream& out, case INTEGER: if (flags & AMOUNT_PRINT_COLORIZE && as_long() < 0) justify(out, to_string(), first_width, - flags & AMOUNT_PRINT_RIGHT_JUSTIFY, true); + flags & AMOUNT_PRINT_RIGHT_JUSTIFY, true); else out << as_long(); break; @@ -1758,7 +1758,7 @@ void value_t::print(std::ostream& out, std::ostringstream buf; as_amount().print(buf, flags); justify(out, buf.str(), first_width, flags & AMOUNT_PRINT_RIGHT_JUSTIFY, - flags & AMOUNT_PRINT_COLORIZE && as_amount().sign() < 0); + flags & AMOUNT_PRINT_COLORIZE && as_amount().sign() < 0); } break; } @@ -1783,9 +1783,9 @@ void value_t::print(std::ostream& out, bool first = true; foreach (const value_t& value, as_sequence()) { if (first) - first = false; + first = false; else - out << ", "; + out << ", "; value.print(out, first_width, latter_width, flags); } @@ -1853,14 +1853,14 @@ void value_t::dump(std::ostream& out, const bool relaxed) const foreach (const char& ch, as_string()) { switch (ch) { case '"': - out << "\\\""; - break; + out << "\\\""; + break; case '\\': - out << "\\\\"; - break; + out << "\\\\"; + break; default: - out << ch; - break; + out << ch; + break; } } out << '"'; @@ -1885,9 +1885,9 @@ void value_t::dump(std::ostream& out, const bool relaxed) const bool first = true; foreach (const value_t& value, as_sequence()) { if (first) - first = false; + first = false; else - out << ", "; + out << ", "; value.dump(out, relaxed); } @@ -1915,7 +1915,7 @@ bool value_t::valid() const } bool sort_value_is_less_than(const std::list<sort_value_t>& left_values, - const std::list<sort_value_t>& right_values) + const std::list<sort_value_t>& right_values) { std::list<sort_value_t>::const_iterator left_iter = left_values.begin(); std::list<sort_value_t>::const_iterator right_iter = right_values.begin(); @@ -1923,16 +1923,16 @@ bool sort_value_is_less_than(const std::list<sort_value_t>& left_values, while (left_iter != left_values.end() && right_iter != right_values.end()) { // Don't even try to sort balance values if (! (*left_iter).value.is_balance() && - ! (*right_iter).value.is_balance()) { + ! (*right_iter).value.is_balance()) { DEBUG("value.sort", - " Comparing " << (*left_iter).value << " < " << (*right_iter).value); + " Comparing " << (*left_iter).value << " < " << (*right_iter).value); if ((*left_iter).value < (*right_iter).value) { - DEBUG("value.sort", " is less"); - return ! (*left_iter).inverted; + DEBUG("value.sort", " is less"); + return ! (*left_iter).inverted; } else if ((*left_iter).value > (*right_iter).value) { - DEBUG("value.sort", " is greater"); - return (*left_iter).inverted; + DEBUG("value.sort", " is greater"); + return (*left_iter).inverted; } } left_iter++; right_iter++; diff --git a/src/value.h b/src/value.h index ff8fe2b0..4dfd591c 100644 --- a/src/value.h +++ b/src/value.h @@ -49,7 +49,7 @@ #ifndef _VALUE_H #define _VALUE_H -#include "balance.h" // includes amount.h +#include "balance.h" // includes amount.h #include "mask.h" namespace ledger { @@ -75,21 +75,21 @@ class expr_t; */ class value_t : public ordered_field_operators<value_t, - equality_comparable<value_t, balance_t, - additive<value_t, balance_t, - multiplicative<value_t, balance_t, - ordered_field_operators<value_t, amount_t, - ordered_field_operators<value_t, double, - ordered_field_operators<value_t, unsigned long, - ordered_field_operators<value_t, long> > > > > > > > + equality_comparable<value_t, balance_t, + additive<value_t, balance_t, + multiplicative<value_t, balance_t, + ordered_field_operators<value_t, amount_t, + ordered_field_operators<value_t, double, + ordered_field_operators<value_t, unsigned long, + ordered_field_operators<value_t, long> > > > > > > > { public: /** * The sequence_t member type abstracts the type used to represent a * resizable "array" of value_t objects. */ - typedef ptr_deque<value_t> sequence_t; - typedef sequence_t::iterator iterator; + typedef ptr_deque<value_t> sequence_t; + typedef sequence_t::iterator iterator; typedef sequence_t::const_iterator const_iterator; typedef sequence_t::difference_type difference_type; @@ -99,18 +99,18 @@ public: * type_t. */ enum type_t { - VOID, // a null value (i.e., uninitialized) - BOOLEAN, // a boolean - DATETIME, // a date and time (Boost posix_time) - DATE, // a date (Boost gregorian::date) - INTEGER, // a signed integer value - AMOUNT, // a ledger::amount_t - BALANCE, // a ledger::balance_t - STRING, // a string object - MASK, // a regular expression mask - SEQUENCE, // a vector of value_t objects - SCOPE, // a pointer to a scope - EXPR // a pointer to a value expression + VOID, // a null value (i.e., uninitialized) + BOOLEAN, // a boolean + DATETIME, // a date and time (Boost posix_time) + DATE, // a date (Boost gregorian::date) + INTEGER, // a signed integer value + AMOUNT, // a ledger::amount_t + BALANCE, // a ledger::balance_t + STRING, // a string object + MASK, // a regular expression mask + SEQUENCE, // a vector of value_t objects + SCOPE, // a pointer to a scope + EXPR // a pointer to a value expression }; private: @@ -128,18 +128,18 @@ private: * The `type' member holds the value_t::type_t value representing * the type of the object stored. */ - variant<bool, // BOOLEAN - datetime_t, // DATETIME - date_t, // DATE - long, // INTEGER - amount_t, // AMOUNT - balance_t *, // BALANCE - string, // STRING - mask_t, // MASK - sequence_t *, // SEQUENCE - scope_t *, // SCOPE - expr_t * // EXPR - > data; + variant<bool, // BOOLEAN + datetime_t, // DATETIME + date_t, // DATE + long, // INTEGER + amount_t, // AMOUNT + balance_t *, // BALANCE + string, // STRING + mask_t, // MASK + sequence_t *, // SEQUENCE + scope_t *, // SCOPE + expr_t * // EXPR + > data; type_t type; @@ -160,7 +160,7 @@ private: TRACE_CTOR(value_t::storage_t, ""); } - public: // so `checked_delete' can access it + public: // so `checked_delete' can access it /** * Destructor. Must only be called when the reference count has * reached zero. The `destroy' method is used to do the actual @@ -193,16 +193,16 @@ private: */ void acquire() const { DEBUG("value.storage.refcount", - "Acquiring " << this << ", refc now " << refc + 1); + "Acquiring " << this << ", refc now " << refc + 1); VERIFY(refc >= 0); refc++; } void release() const { DEBUG("value.storage.refcount", - "Releasing " << this << ", refc now " << refc - 1); + "Releasing " << this << ", refc now " << refc - 1); VERIFY(refc > 0); if (--refc == 0) - checked_delete(this); + checked_delete(this); } friend inline void intrusive_ptr_add_ref(value_t::storage_t * storage) { @@ -216,15 +216,15 @@ private: DEBUG("value.storage.refcount", "Destroying " << this); switch (type) { case VOID: - return; + return; case BALANCE: - checked_delete(boost::get<balance_t *>(data)); - break; + checked_delete(boost::get<balance_t *>(data)); + break; case SEQUENCE: - checked_delete(boost::get<sequence_t *>(data)); - break; + checked_delete(boost::get<sequence_t *>(data)); + break; default: - break; + break; } data = false; type = VOID; @@ -424,8 +424,8 @@ public: temp.in_place_negate(); return temp; } - void in_place_negate(); // exists for efficiency's sake - void in_place_not(); // exists for efficiency's sake + void in_place_negate(); // exists for efficiency's sake + void in_place_not(); // exists for efficiency's sake value_t operator-() const { return negated(); @@ -466,24 +466,24 @@ public: temp.in_place_reduce(); return temp; } - void in_place_reduce(); // exists for efficiency's sake + void in_place_reduce(); // exists for efficiency's sake value_t unreduced() const { value_t temp(*this); temp.in_place_unreduce(); return temp; } - void in_place_unreduce(); // exists for efficiency's sake + void in_place_unreduce(); // exists for efficiency's sake // Return the "market value" of a given value at a specific time. - value_t value(const optional<datetime_t>& moment = none, - const optional<commodity_t&>& in_terms_of = none) const; + value_t value(const optional<datetime_t>& moment = none, + const optional<commodity_t&>& in_terms_of = none) const; value_t price() const; - value_t exchange_commodities(const std::string& commodities, - const bool add_prices = false, - const optional<datetime_t>& moment = none); + value_t exchange_commodities(const std::string& commodities, + const bool add_prices = false, + const optional<datetime_t>& moment = none); /** * Truth tests. @@ -749,9 +749,9 @@ public: * its underlying type, where possible. If not possible, an * exception is thrown. */ - bool to_boolean() const; - int to_int() const; - long to_long() const; + bool to_boolean() const; + int to_int() const; + long to_long() const; datetime_t to_datetime() const; date_t to_date() const; amount_t to_amount() const; @@ -863,13 +863,13 @@ public: std::size_t new_size = seq.size(); if (new_size == 0) { #if BOOST_VERSION >= 103700 - storage.reset(); + storage.reset(); #else - storage = intrusive_ptr<storage_t>(); + storage = intrusive_ptr<storage_t>(); #endif } else if (new_size == 1) { - *this = seq.front(); + *this = seq.front(); } } } @@ -942,9 +942,9 @@ public: * Printing methods. */ void print(std::ostream& out, - const int first_width = -1, - const int latter_width = -1, - const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; + const int first_width = -1, + const int latter_width = -1, + const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const; void dump(std::ostream& out, const bool relaxed = true) const; @@ -1011,7 +1011,7 @@ struct sort_value_t }; bool sort_value_is_less_than(const std::list<sort_value_t>& left_values, - const std::list<sort_value_t>& right_values); + const std::list<sort_value_t>& right_values); void to_xml(std::ostream& out, const value_t& value); diff --git a/src/xact.cc b/src/xact.cc index d943e611..b4438b48 100644 --- a/src/xact.cc +++ b/src/xact.cc @@ -101,9 +101,9 @@ value_t xact_base_t::magnitude() const foreach (const post_t * post, posts) { if (post->amount.sign() > 0) { if (post->cost) - halfbal += *post->cost; + halfbal += *post->cost; else - halfbal += post->amount; + halfbal += post->amount; } } return halfbal; @@ -126,30 +126,30 @@ bool xact_base_t::finalize() if (! p.is_null()) { DEBUG("xact.finalize", "post must balance = " << p.reduced()); if (! post->cost && post->amount.has_annotation() && - post->amount.annotation().price) { - // If the amount has no cost, but is annotated with a per-unit - // price, use the price times the amount as the cost - post->cost = (*post->amount.annotation().price * - post->amount).unrounded(); - DEBUG("xact.finalize", - "annotation price = " << *post->amount.annotation().price); - DEBUG("xact.finalize", "amount = " << post->amount); - DEBUG("xact.finalize", "priced cost = " << *post->cost); - post->add_flags(POST_COST_CALCULATED); - add_or_set_value(balance, post->cost->rounded().reduced()); + post->amount.annotation().price) { + // If the amount has no cost, but is annotated with a per-unit + // price, use the price times the amount as the cost + post->cost = (*post->amount.annotation().price * + post->amount).unrounded(); + DEBUG("xact.finalize", + "annotation price = " << *post->amount.annotation().price); + DEBUG("xact.finalize", "amount = " << post->amount); + DEBUG("xact.finalize", "priced cost = " << *post->cost); + post->add_flags(POST_COST_CALCULATED); + add_or_set_value(balance, post->cost->rounded().reduced()); } else { - // If the amount was a cost, it very likely has the "keep_precision" - // flag set, meaning commodity display precision is ignored when - // displaying the amount. We never want this set for the balance, - // so we must clear the flag in a temporary to avoid it propagating - // into the balance. - add_or_set_value(balance, p.keep_precision() ? - p.rounded().reduced() : p.reduced()); + // If the amount was a cost, it very likely has the "keep_precision" + // flag set, meaning commodity display precision is ignored when + // displaying the amount. We never want this set for the balance, + // so we must clear the flag in a temporary to avoid it propagating + // into the balance. + add_or_set_value(balance, p.keep_precision() ? + p.rounded().reduced() : p.reduced()); } } else if (null_post) { throw_(std::logic_error, - _("Only one posting with null amount allowed per transaction")); + _("Only one posting with null amount allowed per transaction")); } else { null_post = post; @@ -162,7 +162,7 @@ bool xact_base_t::finalize() DEBUG("xact.finalize", "balance is " << balance.label()); if (balance.is_balance()) DEBUG("xact.finalize", "balance commodity count = " - << balance.as_balance().amounts.size()); + << balance.as_balance().amounts.size()); #endif // If there is only one post, balance against the default account if one has @@ -188,15 +188,15 @@ bool xact_base_t::finalize() foreach (post_t * post, posts) { if (! post->amount.is_null() && post->must_balance()) { - if (post->amount.has_annotation()) - top_post = post; - else if (! top_post) - top_post = post; + if (post->amount.has_annotation()) + top_post = post; + else if (! top_post) + top_post = post; } if (post->cost && ! post->has_flags(POST_COST_CALCULATED)) { - saw_cost = true; - break; + saw_cost = true; + break; } } @@ -211,58 +211,58 @@ bool xact_base_t::finalize() const amount_t * y = &(*a++).second; if (x->commodity() != top_post->amount.commodity()) { - const amount_t * t = x; - x = y; - y = t; + const amount_t * t = x; + x = y; + y = t; } if (*x && *y) { - DEBUG("xact.finalize", "primary amount = " << *x); - DEBUG("xact.finalize", "secondary amount = " << *y); - - commodity_t& comm(x->commodity()); - amount_t per_unit_cost; - amount_t total_cost; - const amount_t * prev_y = y; - - foreach (post_t * post, posts) { - if (post != top_post && post->must_balance() && - ! post->amount.is_null() && - post->amount.has_annotation() && - post->amount.annotation().price) { - amount_t temp = *post->amount.annotation().price * post->amount; - if (total_cost.is_null()) { - total_cost = temp; - y = &total_cost; - } - else if (total_cost.commodity() == temp.commodity()) { - total_cost += temp; - } - else { - DEBUG("xact.finalize", - "multiple price commodities, aborting price calc"); - y = prev_y; - break; - } - DEBUG("xact.finalize", "total_cost = " << total_cost); - } - } - per_unit_cost = (*y / *x).abs().unrounded(); - - DEBUG("xact.finalize", "per_unit_cost = " << per_unit_cost); - - foreach (post_t * post, posts) { - const amount_t& amt(post->amount); - - if (post->must_balance() && amt.commodity() == comm) { - balance -= amt; - post->cost = per_unit_cost * amt; - post->add_flags(POST_COST_CALCULATED); - balance += *post->cost; - - DEBUG("xact.finalize", "set post->cost to = " << *post->cost); - } - } + DEBUG("xact.finalize", "primary amount = " << *x); + DEBUG("xact.finalize", "secondary amount = " << *y); + + commodity_t& comm(x->commodity()); + amount_t per_unit_cost; + amount_t total_cost; + const amount_t * prev_y = y; + + foreach (post_t * post, posts) { + if (post != top_post && post->must_balance() && + ! post->amount.is_null() && + post->amount.has_annotation() && + post->amount.annotation().price) { + amount_t temp = *post->amount.annotation().price * post->amount; + if (total_cost.is_null()) { + total_cost = temp; + y = &total_cost; + } + else if (total_cost.commodity() == temp.commodity()) { + total_cost += temp; + } + else { + DEBUG("xact.finalize", + "multiple price commodities, aborting price calc"); + y = prev_y; + break; + } + DEBUG("xact.finalize", "total_cost = " << total_cost); + } + } + per_unit_cost = (*y / *x).abs().unrounded(); + + DEBUG("xact.finalize", "per_unit_cost = " << per_unit_cost); + + foreach (post_t * post, posts) { + const amount_t& amt(post->amount); + + if (post->must_balance() && amt.commodity() == comm) { + balance -= amt; + post->cost = per_unit_cost * amt; + post->add_flags(POST_COST_CALCULATED); + balance += *post->cost; + + DEBUG("xact.finalize", "set post->cost to = " << *post->cost); + } + } } } } @@ -275,39 +275,39 @@ bool xact_base_t::finalize() if (post->amount.commodity() == post->cost->commodity()) throw_(balance_error, - _("A posting's cost must be of a different commodity than its amount")); + _("A posting's cost must be of a different commodity than its amount")); cost_breakdown_t breakdown = commodity_pool_t::current_pool->exchange (post->amount, *post->cost, false, - datetime_t(date(), time_duration(0, 0, 0, 0))); + datetime_t(date(), time_duration(0, 0, 0, 0))); if (post->amount.has_annotation() && - breakdown.basis_cost.commodity() == breakdown.final_cost.commodity()) { + breakdown.basis_cost.commodity() == breakdown.final_cost.commodity()) { if (amount_t gain_loss = breakdown.basis_cost - breakdown.final_cost) { - DEBUG("xact.finalize", "gain_loss = " << gain_loss); - gain_loss.in_place_round(); - DEBUG("xact.finalize", "gain_loss rounds to = " << gain_loss); - - if (post->must_balance()) - add_or_set_value(balance, gain_loss.reduced()); - - account_t * account; - if (gain_loss.sign() > 0) - account = journal->find_account(_("Equity:Capital Gains")); - else - account = journal->find_account(_("Equity:Capital Losses")); - - post_t * p = new post_t(account, gain_loss, ITEM_GENERATED); - p->set_state(post->state()); - if (post->has_flags(POST_VIRTUAL)) { - DEBUG("xact.finalize", "gain_loss came from a virtual post"); - p->add_flags(post->flags() & (POST_VIRTUAL | POST_MUST_BALANCE)); - } - add_post(p); - DEBUG("xact.finalize", "added gain_loss, balance = " << balance); + DEBUG("xact.finalize", "gain_loss = " << gain_loss); + gain_loss.in_place_round(); + DEBUG("xact.finalize", "gain_loss rounds to = " << gain_loss); + + if (post->must_balance()) + add_or_set_value(balance, gain_loss.reduced()); + + account_t * account; + if (gain_loss.sign() > 0) + account = journal->find_account(_("Equity:Capital Gains")); + else + account = journal->find_account(_("Equity:Capital Losses")); + + post_t * p = new post_t(account, gain_loss, ITEM_GENERATED); + p->set_state(post->state()); + if (post->has_flags(POST_VIRTUAL)) { + DEBUG("xact.finalize", "gain_loss came from a virtual post"); + p->add_flags(post->flags() & (POST_VIRTUAL | POST_MUST_BALANCE)); + } + add_post(p); + DEBUG("xact.finalize", "added gain_loss, balance = " << balance); } else { - DEBUG("xact.finalize", "gain_loss would have display as zero"); + DEBUG("xact.finalize", "gain_loss would have display as zero"); } } else { post->amount = breakdown.amount; @@ -315,7 +315,7 @@ bool xact_base_t::finalize() } if (post->has_flags(POST_COST_FIXATED) && - post->amount.has_annotation() && post->amount.annotation().price) { + post->amount.has_annotation() && post->amount.annotation().price) { DEBUG("xact.finalize", "fixating annotation price"); post->amount.annotation().add_flags(ANNOTATION_PRICE_FIXATED); } @@ -332,16 +332,16 @@ bool xact_base_t::finalize() bool first = true; const balance_t& bal(balance.as_balance()); foreach (const balance_t::amounts_map::value_type& pair, bal.amounts) { - if (first) { - null_post->amount = pair.second.negated(); - null_post->add_flags(POST_CALCULATED); - first = false; - } else { - post_t * p = new post_t(null_post->account, pair.second.negated(), - ITEM_GENERATED | POST_CALCULATED); - p->set_state(null_post->state()); - add_post(p); - } + if (first) { + null_post->amount = pair.second.negated(); + null_post->add_flags(POST_CALCULATED); + first = false; + } else { + post_t * p = new post_t(null_post->account, pair.second.negated(), + ITEM_GENERATED | POST_CALCULATED); + p->set_state(null_post->state()); + add_post(p); + } } } else if (balance.is_amount()) { @@ -377,10 +377,10 @@ bool xact_base_t::finalize() foreach (post_t * post, posts) { if (! post->amount.is_null()) { - all_null = false; - post->amount.in_place_reduce(); + all_null = false; + post->amount.in_place_reduce(); } else { - some_null = true; + some_null = true; } post->account->add_post(post); @@ -390,10 +390,10 @@ bool xact_base_t::finalize() } if (all_null) - return false; // ignore this xact completely + return false; // ignore this xact completely else if (some_null) throw_(balance_error, - _("There cannot be null amounts after balancing a transaction")); + _("There cannot be null amounts after balancing a transaction")); } VERIFY(valid()); @@ -419,7 +419,7 @@ bool xact_base_t::verify() // amount. We never want this set for the balance, so we must clear the // flag in a temporary to avoid it propagating into the balance. add_or_set_value(balance, p.keep_precision() ? - p.rounded().reduced() : p.reduced()); + p.rounded().reduced() : p.reduced()); } VERIFY(balance.valid()); @@ -433,7 +433,7 @@ bool xact_base_t::verify() if (post->amount.commodity() == post->cost->commodity()) throw_(amount_error, - _("A posting's cost must be of a different commodity than its amount")); + _("A posting's cost must be of a different commodity than its amount")); } if (! balance.is_null() && ! balance.is_zero()) { @@ -513,7 +513,7 @@ namespace { foreach (post_t * p, post.xact->posts) { bind_scope_t bound_scope(scope, *p); if (expr.calc(bound_scope).to_boolean()) - return true; + return true; } return false; } @@ -528,14 +528,14 @@ namespace { foreach (post_t * p, post.xact->posts) { bind_scope_t bound_scope(scope, *p); if (! expr.calc(bound_scope).to_boolean()) - return false; + return false; } return true; } } expr_t::ptr_op_t xact_t::lookup(const symbol_t::kind_t kind, - const string& name) + const string& name) { if (kind != symbol_t::FUNCTION) return item_t::lookup(kind, name); @@ -601,13 +601,13 @@ namespace { case expr_t::op_t::O_MATCH: if (op->left()->kind == expr_t::op_t::IDENT && - op->left()->as_ident() == "account" && - op->right()->kind == expr_t::op_t::VALUE && - op->right()->as_value().is_mask()) - return op->right()->as_value().as_mask() - .match(post.reported_account()->fullname()); + op->left()->as_ident() == "account" && + op->right()->kind == expr_t::op_t::VALUE && + op->right()->as_value().is_mask()) + return op->right()->as_value().as_mask() + .match(post.reported_account()->fullname()); else - break; + break; case expr_t::op_t::O_NOT: return ! post_pred(op->left(), post); @@ -620,9 +620,9 @@ namespace { case expr_t::op_t::O_QUERY: if (post_pred(op->left(), post)) - return post_pred(op->right()->left(), post); + return post_pred(op->right()->left(), post); else - return post_pred(op->right()->right(), post); + return post_pred(op->right()->right(), post); default: break; @@ -649,109 +649,109 @@ void auto_xact_t::extend_xact(xact_base_t& xact) bool matches_predicate = false; if (try_quick_match) { try { - bool found_memoized_result = false; - if (! memoized_results.empty()) { - std::map<string, bool>::iterator i = - memoized_results.find(initial_post->account->fullname()); - if (i != memoized_results.end()) { - found_memoized_result = true; - matches_predicate = (*i).second; - } - } - - // Since the majority of people who use automated transactions simply - // match against account names, try using a *much* faster version of - // the predicate evaluator. - if (! found_memoized_result) { - matches_predicate = post_pred(predicate.get_op(), *initial_post); - memoized_results.insert - (std::pair<string, bool>(initial_post->account->fullname(), - matches_predicate)); - } + bool found_memoized_result = false; + if (! memoized_results.empty()) { + std::map<string, bool>::iterator i = + memoized_results.find(initial_post->account->fullname()); + if (i != memoized_results.end()) { + found_memoized_result = true; + matches_predicate = (*i).second; + } + } + + // Since the majority of people who use automated transactions simply + // match against account names, try using a *much* faster version of + // the predicate evaluator. + if (! found_memoized_result) { + matches_predicate = post_pred(predicate.get_op(), *initial_post); + memoized_results.insert + (std::pair<string, bool>(initial_post->account->fullname(), + matches_predicate)); + } } catch (...) { - DEBUG("xact.extend.fail", - "The quick matcher failed, going back to regular eval"); - try_quick_match = false; - matches_predicate = predicate(*initial_post); + DEBUG("xact.extend.fail", + "The quick matcher failed, going back to regular eval"); + try_quick_match = false; + matches_predicate = predicate(*initial_post); } } else { matches_predicate = predicate(*initial_post); } if (matches_predicate) { foreach (post_t * post, posts) { - amount_t post_amount; - if (post->amount.is_null()) { - if (! post->amount_expr) - throw_(amount_error, - _("Automated transaction's posting has no amount")); - - bind_scope_t bound_scope(*scope_t::default_scope, *initial_post); - value_t result(post->amount_expr->calc(bound_scope)); - if (result.is_long()) { - post_amount = result.to_amount(); - } else { - if (! result.is_amount()) - throw_(amount_error, - _("Amount expressions must result in a simple amount")); - post_amount = result.as_amount(); - } - } else { - post_amount = post->amount; - } - - amount_t amt; - if (! post_amount.commodity()) - amt = initial_post->amount * post_amount; - else - amt = post_amount; + amount_t post_amount; + if (post->amount.is_null()) { + if (! post->amount_expr) + throw_(amount_error, + _("Automated transaction's posting has no amount")); + + bind_scope_t bound_scope(*scope_t::default_scope, *initial_post); + value_t result(post->amount_expr->calc(bound_scope)); + if (result.is_long()) { + post_amount = result.to_amount(); + } else { + if (! result.is_amount()) + throw_(amount_error, + _("Amount expressions must result in a simple amount")); + post_amount = result.as_amount(); + } + } else { + post_amount = post->amount; + } + + amount_t amt; + if (! post_amount.commodity()) + amt = initial_post->amount * post_amount; + else + amt = post_amount; #if defined(DEBUG_ON) - IF_DEBUG("xact.extend") { - DEBUG("xact.extend", - "Initial post on line " << initial_post->pos->beg_line << ": " - << "amount " << initial_post->amount << " (precision " - << initial_post->amount.precision() << ")"); - - if (initial_post->amount.keep_precision()) - DEBUG("xact.extend", " precision is kept"); - - DEBUG("xact.extend", - "Posting on line " << post->pos->beg_line << ": " - << "amount " << post_amount << ", amt " << amt - << " (precision " << post_amount.precision() - << " != " << amt.precision() << ")"); - - if (post_amount.keep_precision()) - DEBUG("xact.extend", " precision is kept"); - if (amt.keep_precision()) - DEBUG("xact.extend", " amt precision is kept"); - } + IF_DEBUG("xact.extend") { + DEBUG("xact.extend", + "Initial post on line " << initial_post->pos->beg_line << ": " + << "amount " << initial_post->amount << " (precision " + << initial_post->amount.precision() << ")"); + + if (initial_post->amount.keep_precision()) + DEBUG("xact.extend", " precision is kept"); + + DEBUG("xact.extend", + "Posting on line " << post->pos->beg_line << ": " + << "amount " << post_amount << ", amt " << amt + << " (precision " << post_amount.precision() + << " != " << amt.precision() << ")"); + + if (post_amount.keep_precision()) + DEBUG("xact.extend", " precision is kept"); + if (amt.keep_precision()) + DEBUG("xact.extend", " amt precision is kept"); + } #endif // defined(DEBUG_ON) - account_t * account = post->account; - string fullname = account->fullname(); - assert(! fullname.empty()); - - if (contains(fullname, "$account")) { - fullname = regex_replace(fullname, regex("\\$account\\>"), - initial_post->account->fullname()); - while (account->parent) - account = account->parent; - account = account->find_account(fullname); - } - - // Copy over details so that the resulting post is a mirror of - // the automated xact's one. - post_t * new_post = new post_t(account, amt); - new_post->copy_details(*post); - new_post->add_flags(ITEM_GENERATED); - - xact.add_post(new_post); - new_post->account->add_post(new_post); - - if (new_post->must_balance()) - needs_further_verification = true; + account_t * account = post->account; + string fullname = account->fullname(); + assert(! fullname.empty()); + + if (contains(fullname, "$account")) { + fullname = regex_replace(fullname, regex("\\$account\\>"), + initial_post->account->fullname()); + while (account->parent) + account = account->parent; + account = account->find_account(fullname); + } + + // Copy over details so that the resulting post is a mirror of + // the automated xact's one. + post_t * new_post = new post_t(account, amt); + new_post->copy_details(*post); + new_post->add_flags(ITEM_GENERATED); + + xact.add_post(new_post); + new_post->account->add_post(new_post); + + if (new_post->must_balance()) + needs_further_verification = true; } } } @@ -768,7 +768,7 @@ void auto_xact_t::extend_xact(xact_base_t& xact) } void extend_xact_base(journal_t * journal, - xact_base_t& base) + xact_base_t& base) { foreach (auto_xact_t * xact, journal->auto_xacts) xact->extend_xact(base); @@ -816,18 +816,18 @@ void to_xml(std::ostream& out, const xact_t& xact) push_xml y(out, "metadata"); foreach (const item_t::string_map::value_type& pair, *xact.metadata) { if (pair.second.first) { - push_xml z(out, "variable"); - { - push_xml w(out, "key"); - out << y.guard(pair.first); - } - { - push_xml w(out, "value"); - out << y.guard(*pair.second.first); - } + push_xml z(out, "variable"); + { + push_xml w(out, "key"); + out << y.guard(pair.first); + } + { + push_xml w(out, "value"); + out << y.guard(*pair.second.first); + } } else { - push_xml z(out, "tag"); - out << y.guard(pair.first); + push_xml z(out, "tag"); + out << y.guard(pair.first); } } } @@ -106,7 +106,7 @@ class xact_t : public xact_base_t { public: optional<string> code; - string payee; + string payee; xact_t() { TRACE_CTOR(xact_t, ""); @@ -123,7 +123,7 @@ public: string id() const; virtual expr_t::ptr_op_t lookup(const symbol_t::kind_t kind, - const string& name); + const string& name); virtual bool valid() const; @@ -188,7 +188,7 @@ class period_xact_t : public xact_base_t { public: date_interval_t period; - string period_string; + string period_string; period_xact_t() { TRACE_CTOR(period_xact_t, ""); @@ -221,7 +221,7 @@ private: #endif // HAVE_BOOST_SERIALIZATION }; -typedef std::list<xact_t *> xacts_list; +typedef std::list<xact_t *> xacts_list; typedef std::list<auto_xact_t *> auto_xacts_list; typedef std::list<period_xact_t *> period_xacts_list; @@ -43,8 +43,8 @@ namespace ledger { namespace { void xml_account(std::ostream& out, const account_t * acct) { if ((acct->has_xdata() && - acct->xdata().has_flags(ACCOUNT_EXT_VISITED)) || - acct->children_with_flags(ACCOUNT_EXT_VISITED)) { + acct->xdata().has_flags(ACCOUNT_EXT_VISITED)) || + acct->children_with_flags(ACCOUNT_EXT_VISITED)) { out << "<account id=\""; out.width(sizeof(unsigned long) * 2); out.fill('0'); @@ -54,15 +54,15 @@ namespace { out << "<name>" << acct->name << "</name>\n"; value_t total = acct->amount(); if (! total.is_null()) { - out << "<amount>\n"; - to_xml(out, total); - out << "</amount>\n"; + out << "<amount>\n"; + to_xml(out, total); + out << "</amount>\n"; } total = acct->total(); if (! total.is_null()) { - out << "<total>\n"; - to_xml(out, total); - out << "</total>\n"; + out << "<total>\n"; + to_xml(out, total); + out << "</total>\n"; } out << "</account>\n"; } @@ -76,8 +76,8 @@ namespace { foreach (const post_t * post, xact->posts) if (post->has_xdata() && - post->xdata().has_flags(POST_EXT_VISITED)) - to_xml(out, *post); + post->xdata().has_flags(POST_EXT_VISITED)) + to_xml(out, *post); out << "</transaction>\n"; } @@ -115,7 +115,7 @@ void format_xml::operator()(post_t& post) assert(post.xdata().has_flags(POST_EXT_VISITED)); commodities.insert(commodities_pair(post.amount.commodity().symbol(), - &post.amount.commodity())); + &post.amount.commodity())); if (transactions_set.find(post.xact) == transactions_set.end()) transactions.push_back(post.xact); diff --git a/test/UnitTests.cc b/test/UnitTests.cc index 2c5c0406..af3f6311 100644 --- a/test/UnitTests.cc +++ b/test/UnitTests.cc @@ -35,7 +35,7 @@ public: void testInitialization() { assertEqual(std::string("Hello, world!"), - std::string("Hello, world!")); + std::string("Hello, world!")); } private: @@ -61,7 +61,7 @@ int main(int argc, char* argv[]) // Retreive test path from command line first argument. Default to // "" which resolves to the top level suite. std::string testPath = ((argc > index) ? std::string(argv[index]) : - std::string("")); + std::string("")); // Create the event manager and test controller CPPUNIT_NS::TestResult controller; diff --git a/test/UnitTests.h b/test/UnitTests.h index d9314ddf..a7bfcf9e 100644 --- a/test/UnitTests.h +++ b/test/UnitTests.h @@ -6,14 +6,14 @@ #include <cppunit/Portability.h> #define assertDoublesEqual(x,y,z,w) CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(x,y,z,w) -#define assertEqual(x,y) CPPUNIT_ASSERT_EQUAL(x,y) -#define assertNotEqual(x,y) CPPUNIT_ASSERT((x) != (y)) -#define assertTrue(x) CPPUNIT_ASSERT(x) -#define assertFalse(x) CPPUNIT_ASSERT(! (x)) -#define assertValid(x) CPPUNIT_ASSERT((x).valid()) +#define assertEqual(x,y) CPPUNIT_ASSERT_EQUAL(x,y) +#define assertNotEqual(x,y) CPPUNIT_ASSERT((x) != (y)) +#define assertTrue(x) CPPUNIT_ASSERT(x) +#define assertFalse(x) CPPUNIT_ASSERT(! (x)) +#define assertValid(x) CPPUNIT_ASSERT((x).valid()) #define assertEqualMessage(x,y,z) CPPUNIT_ASSERT_EQUAL_MESSAGE(x,y,z) -#define assertMessage(x,y) CPPUNIT_ASSERT_MESSAGE(x,y) -#define assertThrow(x,y) CPPUNIT_ASSERT_THROW(x,y) +#define assertMessage(x,y) CPPUNIT_ASSERT_MESSAGE(x,y) +#define assertThrow(x,y) CPPUNIT_ASSERT_THROW(x,y) #define internalAmount(x) amount_t::exact(x) diff --git a/test/regress/13965214.test b/test/regress/13965214.test index 674d4d7d..29a7278e 100644 --- a/test/regress/13965214.test +++ b/test/regress/13965214.test @@ -3,20 +3,20 @@ reg Y2008 01/30 A - Bank 130 - Income + Bank 130 + Income 02/01 B - Bank 140 - Income + Bank 140 + Income 02/20 C - Bank 150 - Income + Bank 150 + Income 03/01 D - Bank 160 - Income + Bank 160 + Income >>>1 08-Jan-30 A Bank 130 130 Income -130 0 diff --git a/test/regress/5FBF2ED8.test b/test/regress/5FBF2ED8.test index 78df5a6e..ad8454d1 100644 --- a/test/regress/5FBF2ED8.test +++ b/test/regress/5FBF2ED8.test @@ -1,16 +1,16 @@ bal -B <<< -2008/01/01 * Checking balance - Assets:Bank:Checking £0.00 - Equity:Opening Balances +2008/01/01 * Checking balance + Assets:Bank:Checking £0.00 + Equity:Opening Balances -2008/02/02 Salary - Income:Employer £-334.00 - Assets:Bank:Checking $512.85 @@ £334.00 +2008/02/02 Salary + Income:Employer £-334.00 + Assets:Bank:Checking $512.85 @@ £334.00 -2008/03/02 Salary - Income:Employer £-248.07 - Assets:Bank:Checking $404.82 @@ £248.07 +2008/03/02 Salary + Income:Employer £-248.07 + Assets:Bank:Checking $404.82 @@ £248.07 >>>1 £582.07 Assets:Bank:Checking £-582.07 Income:Employer diff --git a/test/regress/86D2BDC4.test b/test/regress/86D2BDC4.test index 8cd51e42..b6d4083c 100644 --- a/test/regress/86D2BDC4.test +++ b/test/regress/86D2BDC4.test @@ -2,7 +2,7 @@ reg -B <<< 2009/06/03 Westjet Expenses:Transportation:Air C$429.80 @ 1.572865 - Expenses:Bank:Fees 2.73 + Expenses:Bank:Fees 2.73 Liabilities:Mastercard >>>1 09-Jun-03 Westjet Ex:Transportation:Air 676.017377 676.017377 diff --git a/test/unit/t_amount.cc b/test/unit/t_amount.cc index 63d82675..b1c7b837 100644 --- a/test/unit/t_amount.cc +++ b/test/unit/t_amount.cc @@ -249,7 +249,7 @@ void AmountTestCase::testAssignment() assertEqual(x10, x9); assertFalse(x1.is_null()); - x1 = x0; // sets x1 back to uninitialized state + x1 = x0; // sets x1 back to uninitialized state assertTrue(x0.is_null()); assertTrue(x1.is_null()); @@ -699,11 +699,11 @@ void AmountTestCase::testCommoditySubtraction() assertEqual(internalAmount("$123454434148472090.138858329277476789"), x7 - x8); assertEqual(string("$123454434148472090.138858329277476789"), (x7 - x8).to_string()); assertEqual(string("$123454434148472090.14"), - (amount_t("$1.00") * (x7 - x8)).to_string()); + (amount_t("$1.00") * (x7 - x8)).to_string()); assertEqual(internalAmount("$-123454434148472090.138858329277476789"), x8 - x7); assertEqual(string("$-123454434148472090.138858329277476789"), (x8 - x7).to_string()); assertEqual(string("$-123454434148472090.14"), - (amount_t("$1.00") * (x8 - x7)).to_string()); + (amount_t("$1.00") * (x8 - x7)).to_string()); assertValid(x1); assertValid(x2); @@ -743,7 +743,7 @@ void AmountTestCase::testIntegerMultiplication() amount_t x4("123456789123456789123456789"); assertEqual(amount_t("15241578780673678546105778281054720515622620750190521"), - x4 * x4); + x4 * x4); assertValid(x1); assertValid(y1); @@ -780,7 +780,7 @@ void AmountTestCase::testFractionalMultiplication() amount_t x2("123456789123456789.123456789123456789"); assertEqual(amount_t("15241578780673678546105778311537878.046486820281054720515622620750190521"), - x2 * x2); + x2 * x2); assertValid(x1); assertValid(y1); @@ -835,7 +835,7 @@ void AmountTestCase::testCommodityMultiplication() amount_t x7(internalAmount("$123456789123456789.123456789123456789")); assertEqual(internalAmount("$15241578780673678546105778311537878.046486820281054720515622620750190521"), - x7 * x7); + x7 * x7); assertValid(x1); assertValid(x2); @@ -877,7 +877,7 @@ void AmountTestCase::testIntegerDivision() assertEqual(string("2204585520061728377204585.517857"), (x4 / y4).to_string()); assertEqual(amount_t("0.000000000000000000000000000001"), - amount_t("10") / amount_t("10000000000000000000000000000000")); + amount_t("10") / amount_t("10000000000000000000000000000000")); assertValid(x1); assertValid(y1); @@ -973,9 +973,9 @@ void AmountTestCase::testCommodityDivision() assertEqual(amount_t("$1"), x7 / x7); assertEqual(string("$0.0019216115121765559608381226612019501"), - (x6 / x7).to_fullstring()); + (x6 / x7).to_fullstring()); assertEqual(string("$520.39654928343335571379527154924040947272"), - (x7 / x6).to_fullstring()); + (x7 / x6).to_fullstring()); assertValid(x1); assertValid(x2); @@ -1110,14 +1110,14 @@ void AmountTestCase::testReduction() amount_t x2("600s"); amount_t x3("6000s"); amount_t x4("360000s"); - amount_t x5("10m"); // 600s - amount_t x6("100m"); // 6000s - amount_t x7("1000m"); // 60000s - amount_t x8("10000m"); // 600000s - amount_t x9("10h"); // 36000s - amount_t x10("100h"); // 360000s - amount_t x11("1000h"); // 3600000s - amount_t x12("10000h"); // 36000000s + amount_t x5("10m"); // 600s + amount_t x6("100m"); // 6000s + amount_t x7("1000m"); // 60000s + amount_t x8("10000m"); // 600000s + amount_t x9("10h"); // 36000s + amount_t x10("100h"); // 360000s + amount_t x11("1000h"); // 3600000s + amount_t x12("10000h"); // 36000000s assertThrow(x0.reduce(), amount_error); assertThrow(x0.unreduce(), amount_error); @@ -1220,7 +1220,7 @@ void AmountTestCase::testCommodityForZero() { amount_t x1(internalAmount("$0.000000000000000000001")); - assertTrue(x1); // an internal amount never betrays its precision + assertTrue(x1); // an internal amount never betrays its precision assertFalse(x1.is_zero()); assertFalse(x1.is_realzero()); @@ -1287,7 +1287,7 @@ void AmountTestCase::testPrinting() x1.print(bufstr); assertEqual(std::string("982340823.380238098235098235098235098"), - bufstr.str()); + bufstr.str()); } assertValid(x0); @@ -1304,7 +1304,7 @@ void AmountTestCase::testCommodityPrinting() x1.print(bufstr); assertEqual(std::string("$982340823.386238098235098235098235098"), - bufstr.str()); + bufstr.str()); } { @@ -1312,7 +1312,7 @@ void AmountTestCase::testCommodityPrinting() (x1 * x2).print(bufstr); assertEqual(std::string("$964993493285024293.18099172508158508135413499124"), - bufstr.str()); + bufstr.str()); } { diff --git a/test/unit/t_times.cc b/test/unit/t_times.cc index d8a67b43..aaf31263 100644 --- a/test/unit/t_times.cc +++ b/test/unit/t_times.cc @@ -22,8 +22,8 @@ void DateTimeTestCase::tearDown() void DateTimeTestCase::testConstructors() { #ifndef NOT_FOR_PYTHON - std::time_t now = std::time(NULL); - struct tm * moment = std::localtime(&now); + std::time_t now = std::time(NULL); + struct tm * moment = std::localtime(&now); std::time_t localMoment = std::mktime(moment); #endif // NOT_FOR_PYTHON diff --git a/tools/pre-commit b/tools/pre-commit index 2f8ded1a..fb62c49d 100755 --- a/tools/pre-commit +++ b/tools/pre-commit @@ -10,7 +10,7 @@ if echo $(git rev-parse --symbolic-full-name HEAD) | \ fi # These are the locations I keep my temporary source and build trees in -PRODUCTS=$(./acprep products) # generates a build directory name such as +PRODUCTS=$(./acprep products) # generates a build directory name such as # ~/Products/ledger TMPDIR=$PRODUCTS/ledger/pre-commit MIRROR=$PRODUCTS/ledger/pre-commit-mirror @@ -46,11 +46,11 @@ if [ ! -f Makefile -o \ \( -f acprep -a acprep -nt Makefile \) ] then if [ -f acprep ]; then - echo Will run acprep in a moment + echo Will run acprep in a moment elif [ -f autogen.sh ]; then - sh autogen.sh && ./configure + sh autogen.sh && ./configure else - autoreconf && ./configure + autoreconf && ./configure fi fi diff --git a/tools/proof b/tools/proof index 5a329a50..7e345234 100755 --- a/tools/proof +++ b/tools/proof @@ -19,10 +19,10 @@ time ./acprep --universal -j16 --warn proof 2>&1 | \ if egrep -q '(ERROR|CRITICAL)' ~/Desktop/proof.log; then if [[ "$1" = "--alert" ]]; then - notify "Ledger proof build FAILED" + notify "Ledger proof build FAILED" else - echo "Ledger proof build FAILED" - exit 1 + echo "Ledger proof build FAILED" + exit 1 fi else echo "Ledger proof build succeeded" |