Several fixes to lot price handling.

Makefile.am

@@ -28,6 +28,7 @@ libledger_la_SOURCES = \
 	qif.cc	       \
 	quotes.cc      \
 	reconcile.cc   \
+	report.cc      \
 	startup.cc     \
 	textual.cc     \
 	valexpr.cc     \
@@ -74,6 +75,7 @@ pkginclude_HEADERS = \
 	qif.h	     \
 	quotes.h     \
 	reconcile.h  \
+	report.h     \
 	textual.h    \
 	timing.h     \
 	valexpr.h    \

NEWS

@@ -111,6 +111,15 @@
   expression which is evaluated as a boolean to locate the desired
   reported transaction.
 
+- Added a "dump" command for creating binary files, which load much
+  faster than their textual originals.  For example:
+
+    ledger -f huge.dat -o huge.cache dump
+    ledger -f huge.cache bal
+
+  The second command will load significantly faster (usually about six
+  times on my machine).
+
 - There have a few changes to value expression syntax.  The most
   significant incompatibilities being:
 

amount.cc

@@ -217,6 +217,8 @@ amount_t::amount_t(const double value)
 
 void amount_t::_release()
 {
+  DEBUG_PRINT("amounts.refs",
+	      quantity << " ref--, now " << (quantity->ref - 1));
   if (--quantity->ref == 0) {
     if (! (quantity->flags & BIGINT_BULK_ALLOC))
       delete quantity;
@@ -257,6 +259,8 @@ void amount_t::_copy(const amount_t& amt)
       quantity = new bigint_t(*amt.quantity);
     } else {
       quantity = amt.quantity;
+      DEBUG_PRINT("amounts.refs",
+		  quantity << " ref++, now " << (quantity->ref + 1));
       quantity->ref++;
     }
   }
@@ -506,8 +510,7 @@ int amount_t::compare(const amount_t& amt) const
   if (! amt.quantity)
     return sign();
 
-  if (commodity() && amt.commodity() &&
+  if (commodity() && amt.commodity() && commodity() != amt.commodity())
-      commodity() != amt.commodity())
     throw new amount_error
       (std::string("Cannot compare amounts with different commodities: ") +
        commodity().symbol() + " and " + amt.commodity().symbol());
@@ -619,7 +622,7 @@ amount_t amount_t::round(unsigned int prec) const
   amount_t temp = *this;
 
   if (! quantity || quantity->prec <= prec) {
-    if (quantity->flags & BIGINT_KEEP_PREC) {
+    if (quantity && quantity->flags & BIGINT_KEEP_PREC) {
       temp._dup();
       temp.quantity->flags &= ~BIGINT_KEEP_PREC;
     }
@@ -1276,6 +1279,8 @@ void amount_t::read_quantity(char *& data)
     data += sizeof(unsigned int);
 
     quantity = (bigint_t *) (bigints + (index - 1) * sizeof(bigint_t));
+    DEBUG_PRINT("amounts.refs",
+		quantity << " ref++, now " << (quantity->ref + 1));
     quantity->ref++;
   }
 }
@@ -1625,7 +1630,7 @@ amount_t commodity_base_t::value(const std::time_t moment)
     }
   }
 
-  if (updater)
+  if (updater && ! (flags & COMMODITY_STYLE_NOMARKET))
     (*updater)(*this, moment, age,
 	       (history && history->prices.size() > 0 ?
 		(*history->prices.rbegin()).first : 0), price);

balance.cc

@@ -197,9 +197,8 @@ balance_t& balance_t::operator*=(const amount_t& amt)
 	 i++)
       (*i).second *= amt;
   }
-  else if (amounts.size() == 1 &&
+  else if (amounts.size() == 1) {
-	   (*amounts.begin()).first == &amt.commodity()) {
+    *this = (*amounts.begin()).second * amt;
-    (*amounts.begin()).second *= amt;
   }
   else {
     amounts_map::iterator i = amounts.find(&amt.commodity());
@@ -208,9 +207,8 @@ balance_t& balance_t::operator*=(const amount_t& amt)
     } else {
       // Try stripping annotations before giving an error.
       balance_t temp(strip_annotations());
-      if (temp.amounts.size() == 1 &&
+      if (temp.amounts.size() == 1) {
-	  (*temp.amounts.begin()).first == &amt.commodity()) {
+	return *this = (*temp.amounts.begin()).second * amt;
-	return *this = temp * amt;
       } else {
 	i = temp.amounts.find(&amt.commodity());
 	if (i != temp.amounts.end())

balance.h

@@ -449,6 +449,19 @@ class balance_t
       (*i).second.abs();
   }
 
+  void reduce() {
+    for (amounts_map::iterator i = amounts.begin();
+	 i != amounts.end();
+	 i++)
+      (*i).second.reduce();
+  }
+
+  balance_t reduced() const {
+    balance_t temp(*this);
+    temp.reduce();
+    return temp;
+  }
+
   void round() {
     for (amounts_map::iterator i = amounts.begin();
 	 i != amounts.end();
@@ -893,6 +906,17 @@ class balance_pair_t
     return quantity.valid() && (! cost || cost->valid());
   }
 
+  void reduce() {
+    quantity.reduce();
+    if (cost) cost->reduce();
+  }
+
+  balance_pair_t reduced() const {
+    balance_pair_t temp(*this);
+    temp.reduce();
+    return temp;
+  }
+
   void round() {
     quantity.round();
     if (cost) cost->round();

binary.cc

@@ -456,7 +456,7 @@ inline void read_binary_commodity_base_extra(char *& data,
 
     // Upon insertion, amt will be copied, which will cause the amount
     // to be duplicated (and thus not lost when the journal's
-    // item_pool is deleted.
+    // item_pool is deleted).
     if (! commodity->history)
       commodity->history = new commodity_base_t::history_t;
     commodity->history->prices.insert(history_pair(when, amt));
@@ -509,7 +509,14 @@ inline commodity_t * read_binary_commodity_annotated(char *& data)
 
   commodity->ptr =
     commodities[read_binary_long<commodity_t::ident_t>(data) - 1];
-  read_binary_amount(data, commodity->price);
+
+  // This read-and-then-assign causes a new amount to be allocated
+  // which does not live within the bulk allocation pool, since that
+  // pool will be deleted *before* the commodities are destroyed.
+  amount_t amt;
+  read_binary_amount(data, amt);
+  commodity->price = amt;
+
   read_binary_long(data, commodity->date);
   read_binary_string(data, commodity->tag);
 
@@ -540,7 +547,7 @@ account_t * read_binary_account(char *& data, journal_t * journal,
   // account, throw away what we've learned about the recorded
   // journal's own master account.
 
-  if (master) {
+  if (master && acct != master) {
     delete acct;
     acct = master;
   }
@@ -551,6 +558,7 @@ account_t * read_binary_account(char *& data, journal_t * journal,
        i++) {
     account_t * child = read_binary_account(data, journal);
     child->parent = acct;
+    assert(acct != child);
     acct->add_account(child);
   }
 
@@ -575,9 +583,6 @@ unsigned int read_binary_journal(std::istream&	    in,
 	 i < count;
 	 i++) {
       std::string path = read_binary_string(in);
-      if (i == 0 && path != file)
-	return 0;
-
       std::time_t old_mtime;
       read_binary_long(in, old_mtime);
       struct stat info;
@@ -609,7 +614,8 @@ unsigned int read_binary_journal(std::istream&	    in,
   account_t::ident_t a_count = read_binary_long<account_t::ident_t>(data);
   accounts = accounts_next = new account_t *[a_count];
 
-  assert(journal->master); delete journal->master;
+  assert(journal->master);
+  delete journal->master;
   journal->master = read_binary_account(data, journal, master);
 
   if (read_binary_number<bool>(data))
@@ -650,9 +656,6 @@ unsigned int read_binary_journal(std::istream&	    in,
   for (commodity_base_t::ident_t i = 0; i < bc_count; i++) {
     commodity_base_t * commodity = read_binary_commodity_base(data);
 
-    if (commodity->flags & COMMODITY_STYLE_BUILTIN)
-      commodity_base_t::commodities.erase(commodity->symbol);
-
     std::pair<base_commodities_map::iterator, bool> result =
       commodity_base_t::commodities.insert
       (base_commodities_pair(commodity->symbol, commodity));
@@ -663,8 +666,7 @@ unsigned int read_binary_journal(std::istream&	    in,
       // It's possible the user might have used a commodity in a value
       // expression passed to an option, we'll just override the
       // flags, but keep the commodity pointer intact.
-      if (c == commodity_base_t::commodities.end() ||
+      if (c == commodity_base_t::commodities.end())
-	  (*c).second->smaller || (*c).second->larger)
 	throw new error(std::string("Failed to read base commodity from cache: ") +
 			commodity->symbol);
 
@@ -672,10 +674,15 @@ unsigned int read_binary_journal(std::istream&	    in,
       (*c).second->note	     = commodity->note;
       (*c).second->precision = commodity->precision;
       (*c).second->flags     = commodity->flags;
+      if ((*c).second->smaller)
+	delete (*c).second->smaller;
       (*c).second->smaller   = commodity->smaller;
+      if ((*c).second->larger)
+	delete (*c).second->larger;
       (*c).second->larger    = commodity->larger;
 
       *(base_commodities_next - 1) = (*c).second;
+      delete commodity;
     }
   }
 
@@ -694,20 +701,19 @@ unsigned int read_binary_journal(std::istream&	    in,
       commodity = read_binary_commodity_annotated(data);
     }
 
-    if (commodity->flags() & COMMODITY_STYLE_BUILTIN) {
-      commodity_t::commodities.erase(mapping_key);
-      if (commodity->symbol() == "") {
-	delete commodity_t::null_commodity;
-	commodity_t::null_commodity = commodity;
-      }
-    }
-
     std::pair<commodities_map::iterator, bool> result =
-      commodity_t::commodities.insert(commodities_pair(mapping_key,
+      commodity_t::commodities.insert(commodities_pair
-						       commodity));
+				        (mapping_key, commodity));
-    if (! result.second && commodity->annotated)
+    if (! result.second) {
-      throw new error(std::string("Failed to read commodity from cache: ") +
+      commodities_map::iterator c =
-		      commodity->base->symbol);
+	commodity_t::commodities.find(mapping_key);
+      if (c == commodity_t::commodities.end())
+	throw new error(std::string("Failed to read commodity from cache: ") +
+			commodity->symbol());
+
+      *(commodities_next - 1) = (*c).second;
+      delete commodity;
+    }
   }
 
   for (commodity_base_t::ident_t i = 0; i < bc_count; i++)

config.h

@@ -13,112 +13,38 @@ namespace ledger {
 class config_t
 {
  public:
-  // These options can all be set used text fields.
+  std::string init_file;
+  std::string data_file;
+  std::string cache_file;
+  std::string price_db;
 
-  strings_list  price_settings;
+  std::string balance_format;
-  std::string   init_file;
+  std::string register_format;
-  std::string   data_file;
+  std::string wide_register_format;
-  std::string   cache_file;
+  std::string csv_register_format;
-  std::string   price_db;
+  std::string plot_amount_format;
-  std::string   output_file;
+  std::string plot_total_format;
-  std::string   account;
+  std::string print_format;
-  std::string   predicate;
+  std::string write_hdr_format;
-  std::string   secondary_predicate;
+  std::string write_xact_format;
-  std::string   display_predicate;
+  std::string equity_format;
-  std::string   report_period;
+  std::string prices_format;
-  std::string   report_period_sort;
+  std::string pricesdb_format;
-  std::string   format_string;
-  std::string   balance_format;
-  std::string   register_format;
-  std::string   wide_register_format;
-  std::string   csv_register_format;
-  std::string   plot_amount_format;
-  std::string   plot_total_format;
-  std::string   print_format;
-  std::string   write_hdr_format;
-  std::string   write_xact_format;
-  std::string   equity_format;
-  std::string   prices_format;
-  std::string   pricesdb_format;
-  std::string   date_format;
-  std::string   sort_string;
-  std::string   amount_expr;
-  std::string   total_expr;
-  std::string   descend_expr;
-  std::string   forecast_limit;
-  std::string   reconcile_balance;
-  std::string   reconcile_date;
-  std::string   pager;
-  unsigned long budget_flags;
-  unsigned long pricing_leeway;
-  int           head_entries;
-  int           tail_entries;
-  bool		show_collapsed;
-  bool		show_subtotal;
-  bool		show_totals;
-  bool		show_related;
-  bool		show_all_related;
-  bool		show_inverted;
-  bool		show_empty;
-  bool		days_of_the_week;
-  bool		by_payee;
-  bool		comm_as_payee;
-  bool		code_as_payee;
-  bool		show_revalued;
-  bool		show_revalued_only;
-  bool		download_quotes;
-  bool          use_cache;
-  bool          cache_dirty;
-  bool          debug_mode;
-  bool          verbose_mode;
-  bool          trace_mode;
-  bool          keep_price;
-  bool          keep_date;
-  bool          keep_tag;
-  bool          entry_sort;
-  bool          sort_all;
 
-  config_t() {
+  std::string account;
-    reset();
+  std::string pager;
-  }
-  config_t(const config_t&) {
-    assert(0);
-  }
-  void reset();
 
-  void regexps_to_predicate(const std::string& command,
+  bool download_quotes;
-			    std::list<std::string>::const_iterator begin,
+  bool use_cache;
-			    std::list<std::string>::const_iterator end,
+  bool cache_dirty;
-			    const bool account_regexp	       = false,
+  bool debug_mode;
-			    const bool add_account_short_masks = false,
+  bool verbose_mode;
-			    const bool logical_and             = true);
+  bool trace_mode;
 
-  bool process_option(const std::string& opt, const char * arg = NULL);
+  config_t();
-  void process_arguments(int argc, char ** argv, const bool anywhere,
-			 std::list<std::string>& args);
-  void process_environment(char ** envp, const std::string& tag);
-
-  void process_options(const std::string&     command,
-		       strings_list::iterator arg,
-		       strings_list::iterator args_end);
-
-  item_handler<transaction_t> *
-  chain_xact_handlers(const std::string& command,
-		      item_handler<transaction_t> * base_formatter,
-		      journal_t * journal,
-		      account_t * master,
-		      std::list<item_handler<transaction_t> *>& ptrs);
 };
 
-#define CONFIG_OPTIONS_SIZE 94
+//////////////////////////////////////////////////////////////////////
-extern option_t config_options[CONFIG_OPTIONS_SIZE];
-
-void option_help(std::ostream& out);
-
-#define OPT_BEGIN(tag, chars)			\
-    void opt_ ## tag(const char * optarg)
-
-#define OPT_END(tag)
 
 std::string resolve_path(const std::string& path);
 

journal.cc

@@ -468,11 +468,17 @@ bool account_t::valid() const
 
   for (accounts_map::const_iterator i = accounts.begin();
        i != accounts.end();
-       i++)
+       i++) {
+    if (this == (*i).second) {
+      DEBUG_PRINT("ledger.validate", "account_t: parent refers to itself!");
+      return false;
+    }
+
     if (! (*i).second->valid()) {
       DEBUG_PRINT("ledger.validate", "account_t: child not valid");
       return false;
     }
+  }
 
   return true;
 }

ledger.h

@@ -45,5 +45,6 @@ namespace ledger {
 }
 
 #include <config.h>
+#include <report.h>
 
 #endif // _LEDGER_H

main.cc

@@ -23,7 +23,8 @@
 
 using namespace ledger;
 
-int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
+int parse_and_report(config_t& config, report_t& report,
+		     int argc, char * argv[], char * envp[])
 {
   // Configure the terminus for value expressions
 
@@ -32,7 +33,7 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
   // Parse command-line arguments, and those set in the environment
 
   std::list<std::string> args;
-  config.process_arguments(argc - 1, argv + 1, false, args);
+  process_arguments(ledger::config_options, argc - 1, argv + 1, false, args);
 
   if (args.empty()) {
     option_help(std::cerr);
@@ -48,19 +49,19 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
 
   TRACE(main, "Processing options and environment variables");
 
-  config.process_environment(envp, "LEDGER_");
+  process_environment(ledger::config_options, envp, "LEDGER_");
 
 #if 1
   // These are here for backwards compatability, but are deprecated.
 
   if (const char * p = std::getenv("LEDGER"))
-    config.process_option("file", p);
+    process_option(ledger::config_options, "file", p);
   if (const char * p = std::getenv("LEDGER_INIT"))
-    config.process_option("init-file", p);
+    process_option(ledger::config_options, "init-file", p);
   if (const char * p = std::getenv("PRICE_HIST"))
-    config.process_option("price-db", p);
+    process_option(ledger::config_options, "price-db", p);
   if (const char * p = std::getenv("PRICE_EXP"))
-    config.process_option("price-exp", p);
+    process_option(ledger::config_options, "price-exp", p);
 #endif
 
   const char * p    = std::getenv("HOME");
@@ -100,6 +101,8 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
     command = "p";
   else if (command == "output")
     command = "w";
+  else if (command == "dump")
+    command = "W";
   else if (command == "emacs" || command == "lisp")
     command = "x";
   else if (command == "xml")
@@ -118,6 +121,7 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
   }
   else if (command == "parse") {
     value_expr expr(ledger::parse_value_expr(*arg));
+
     if (config.verbose_mode) {
       std::cout << "Value expression tree:" << std::endl;
       ledger::dump_value_expr(std::cout, expr.get());
@@ -127,20 +131,9 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
       std::cout << std::endl << std::endl;
       std::cout << "Result of computation: ";
     }
-    value_t result = guarded_compute(expr.get());
 
-    if (! config.keep_price || ! config.keep_date || ! config.keep_tag) {
+    value_t result = guarded_compute(expr.get());
-      switch (result.type) {
+    std::cout << result.strip_annotations() << std::endl;
-      case value_t::AMOUNT:
-      case value_t::BALANCE:
-      case value_t::BALANCE_PAIR:
-	result = result.strip_annotations();
-	break;
-      default:
-	break;
-      }
-    }
-    std::cout << result << std::endl;
 
     return 0;
   }
@@ -171,11 +164,23 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
       throw new error("The 'output' command requires a file argument");
     first_arg = *arg++;
   }
+  else if (command == "W") {
+    if (report.output_file.empty())
+      throw new error("The 'dump' command requires use of the --output option");
+  }
 
   TRACE(options, std::string("Post-processing options ") +
 	"for command \"" + command + "\"");
 
-  config.process_options(command, arg, args.end());
+  report.process_options(command, arg, args.end());
+
+  // If downloading is to be supported, configure the updater
+
+  // jww (2006-03-23): Should the pricing_leeway be in config_t?
+  // Should download_quotes be in report_t?
+  if (! commodity_base_t::updater && config.download_quotes)
+    commodity_base_t::updater =
+      new quotes_by_script(config.price_db, report.pricing_leeway, config.cache_dirty);
 
   std::auto_ptr<entry_t> new_entry;
   if (command == "e") {
@@ -191,8 +196,8 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
 #endif
   std::ostream * out = &std::cout;
 
-  if (! config.output_file.empty()) {
+  if (! report.output_file.empty()) {
-    out = new std::ofstream(config.output_file.c_str());
+    out = new std::ofstream(report.output_file.c_str());
   }
 #ifdef HAVE_UNIX_PIPES
   else if (! config.pager.empty()) {
@@ -242,6 +247,7 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
 
   if (command == "expr") {
     value_expr expr(ledger::parse_value_expr(*arg));
+
     if (config.verbose_mode) {
       std::cout << "Value expression tree:" << std::endl;
       ledger::dump_value_expr(std::cout, expr.get());
@@ -251,20 +257,9 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
       std::cout << std::endl << std::endl;
       std::cout << "Result of computation: ";
     }
-    value_t result = guarded_compute(expr.get());
 
-    if (! config.keep_price || ! config.keep_date || ! config.keep_tag) {
+    value_t result = guarded_compute(expr.get());
-      switch (result.type) {
+    std::cout << result.strip_annotations() << std::endl;
-      case value_t::AMOUNT:
-      case value_t::BALANCE:
-      case value_t::BALANCE_PAIR:
-	result = result.strip_annotations();
-	break;
-      default:
-	break;
-      }
-    }
-    std::cout << result << std::endl;
 
     return 0;
   }
@@ -273,8 +268,8 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
 
   const std::string * format;
 
-  if (! config.format_string.empty())
+  if (! report.format_string.empty())
-    format = &config.format_string;
+    format = &report.format_string;
   else if (command == "b")
     format = &config.balance_format;
   else if (command == "r")
@@ -301,13 +296,14 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
     formatter = new format_entries(*out, *format);
   else if (command == "x")
     formatter = new format_emacs_transactions(*out);
-  else if (command == "X") {
 #if defined(HAVE_EXPAT) || defined(HAVE_XMLPARSE)
-    formatter = new format_xml_entries(*out, config.show_totals);
+  else if (command == "X")
+    formatter = new format_xml_entries(*out, report.show_totals);
 #else
+  else if (command == "X")
     throw new error("XML support was not compiled into this copy of Ledger");
 #endif
-  } else
+  else
     formatter = new format_transactions(*out, *format);
 
   if (command == "w") {
@@ -315,10 +311,17 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
     write_textual_journal(*journal, first_arg, *formatter,
 			  config.write_hdr_format, *out);
     TRACE_POP(text_writer, "Finished writing");
-  } else {
+  }
+  else if (command == "W") {
+    TRACE_PUSH(binary_writer, "Writing binary file");
+    std::ofstream stream(report.output_file.c_str());
+    write_binary_journal(stream, journal.get());
+    TRACE_POP(binary_writer, "Finished writing");
+  }
+  else {
     TRACE_PUSH(main, "Walking journal entries");
 
-    formatter = config.chain_xact_handlers(command, formatter, journal.get(),
+    formatter = report.chain_xact_handlers(command, formatter, journal.get(),
 					   journal->master, formatter_ptrs);
     if (command == "e")
       walk_transactions(new_entry->transactions, *formatter);
@@ -338,14 +341,14 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
   if (command == "b") {
     TRACE_PUSH(main, "Walking journal accounts");
 
-    format_account acct_formatter(*out, *format, config.display_predicate);
+    format_account acct_formatter(*out, *format, report.display_predicate);
     sum_accounts(*journal->master);
-    walk_accounts(*journal->master, acct_formatter, config.sort_string);
+    walk_accounts(*journal->master, acct_formatter, report.sort_string);
     acct_formatter.flush();
 
     if (account_has_xdata(*journal->master)) {
       account_xdata_t& xdata = account_xdata(*journal->master);
-      if (! config.show_collapsed && xdata.total) {
+      if (! report.show_collapsed && xdata.total) {
 	*out << "--------------------\n";
 	xdata.value = xdata.total;
 	acct_formatter.format.format(*out, details_t(*journal->master));
@@ -356,9 +359,9 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
   else if (command == "E") {
     TRACE_PUSH(main, "Walking journal accounts");
 
-    format_equity acct_formatter(*out, *format, config.display_predicate);
+    format_equity acct_formatter(*out, *format, report.display_predicate);
     sum_accounts(*journal->master);
-    walk_accounts(*journal->master, acct_formatter, config.sort_string);
+    walk_accounts(*journal->master, acct_formatter, report.sort_string);
     acct_formatter.flush();
 
     TRACE_POP(main, "Finished account walk");
@@ -373,7 +376,7 @@ int parse_and_report(config_t& config, int argc, char * argv[], char * envp[])
   clear_account_xdata acct_cleaner;
   walk_accounts(*journal->master, acct_cleaner);
 
-  if (! config.output_file.empty())
+  if (! report.output_file.empty())
     delete out;
 
   for (std::list<item_handler<transaction_t> *>::iterator i
@@ -419,8 +422,11 @@ int main(int argc, char * argv[], char * envp[])
     ledger::do_cleanup = false;
 #endif
     config_t config;
-    TRACE_PUSH(main, "Starting Ledger " PACKAGE_VERSION);
+    report_t report;
-    int status = parse_and_report(config, argc, argv, envp);
+    ledger::config = &config;
+    ledger::report = &report;
+    TRACE_PUSH(main, "Ledger starting");
+    int status = parse_and_report(config, report, argc, argv, envp);
     TRACE_POP(main, "Ledger done");
     return status;
   }

option.cc

@@ -1,5 +1,6 @@
 #include "option.h"
 #include "config.h"
+#include "report.h"
 #include "debug.h"
 #include "error.h"
 
@@ -166,3 +167,876 @@ void process_environment(option_t * options, char ** envp,
       }
     }
 }
+
+//////////////////////////////////////////////////////////////////////
+
+namespace ledger {
+
+config_t * config = NULL;
+report_t * report = NULL;
+
+static void show_version(std::ostream& out)
+{
+  out << "Ledger " << ledger::version << ", the command-line accounting tool";
+  out << "\n\nCopyright (c) 2003-2006, John Wiegley.  All rights reserved.\n\n\
+This program is made available under the terms of the BSD Public License.\n\
+See LICENSE file included with the distribution for details and disclaimer.\n";
+  out << "\n(modules: gmp, pcre";
+#if defined(HAVE_EXPAT) || defined(HAVE_XMLPARSE)
+  out << ", xml";
+#endif
+#ifdef HAVE_LIBOFX
+  out << ", ofx";
+#endif
+  out << ")\n";
+}
+
+void option_full_help(std::ostream& out)
+{
+  out << "usage: ledger [options] COMMAND [ACCT REGEX]... [-- [PAYEE REGEX]...]\n\n\
+Basic options:\n\
+  -H, --full-help        display this help text\n\
+  -h, --help             display summarized help text\n\
+  -v, --version          show version information\n\
+  -f, --file FILE        read ledger data from FILE\n\
+  -o, --output FILE      write output to FILE\n\
+  -i, --init-file FILE   initialize ledger using FILE (default: ~/.ledgerrc)\n\
+      --cache FILE       use FILE as a binary cache when --file is not used\n\
+      --no-cache         don't use a cache, even if it would be appropriate\n\
+  -a, --account NAME     use NAME for the default account (useful with QIF)\n\n\
+Report filtering:\n\
+  -c, --current          show only current and past entries (not future)\n\
+  -b, --begin DATE       set report begin date\n\
+  -e, --end DATE         set report end date\n\
+  -p, --period STR       report using the given period\n\
+      --period-sort EXPR sort each report period's entries by EXPR\n\
+  -C, --cleared          consider only cleared transactions\n\
+  -U, --uncleared        consider only uncleared transactions\n\
+  -R, --real             consider only real (non-virtual) transactions\n\
+  -L, --actual           consider only actual (non-automated) transactions\n\
+  -r, --related          calculate report using related transactions\n\
+      --budget           generate budget entries based on FILE\n\
+      --add-budget       show all transactions plus the budget\n\
+      --unbudgeted       show only unbudgeted transactions\n\
+      --forecast EXPR    generate forecast entries while EXPR is true\n\
+  -l, --limit EXPR       calculate only transactions matching EXPR\n\
+  -t, --amount EXPR      use EXPR to calculate the displayed amount\n\
+  -T, --total EXPR       use EXPR to calculate the displayed total\n\n\
+Output customization:\n\
+  -n, --collapse         register: collapse entries; balance: no grand total\n\
+  -s, --subtotal         balance: show sub-accounts; other: show subtotals\n\
+  -P, --by-payee         show summarized totals by payee\n\
+  -x, --comm-as-payee    set commodity name as the payee, for reporting\n\
+  -E, --empty            balance: show accounts with zero balance\n\
+  -W, --weekly           show weekly sub-totals\n\
+  -M, --monthly          show monthly sub-totals\n\
+  -Y, --yearly           show yearly sub-totals\n\
+      --dow              show a days-of-the-week report\n\
+  -S, --sort EXPR        sort report according to the value expression EXPR\n\
+  -w, --wide             for the default register report, use 132 columns\n\
+      --head COUNT       show only the first COUNT entries (negative inverts)\n\
+      --tail COUNT       show only the last COUNT entries (negative inverts)\n\
+      --pager PAGER      send all output through the given PAGER program\n\
+  -A, --average          report average transaction amount\n\
+  -D, --deviation        report deviation from the average\n\
+  -%, --percentage       report balance totals as a percentile of the parent\n\
+      --totals           in the \"xml\" report, include running total\n\
+  -j, --amount-data      print only raw amount data (useful for scripting)\n\
+  -J, --total-data       print only raw total data\n\
+  -d, --display EXPR     display only transactions matching EXPR\n\
+  -y, --date-format STR  use STR as the date format (default: %Y/%m/%d)\n\
+  -F, --format STR       use STR as the format; for each report type, use:\n\
+      --balance-format      --register-format       --print-format\n\
+      --plot-amount-format  --plot-total-format     --equity-format\n\
+      --prices-format       --wide-register-format\n\n\
+Commodity reporting:\n\
+      --price-db FILE    sets the price database to FILE (def: ~/.pricedb)\n\
+  -L, --price-exp MINS   download quotes only if newer than MINS (def: 1440)\n\
+  -Q, --download         download price information when needed\n\
+  -O, --quantity         report commodity totals (this is the default)\n\
+  -B, --basis            report cost basis of commodities\n\
+  -V, --market           report last known market value\n\
+  -g, --performance      report gain/loss for each displayed transaction\n\
+  -G, --gain             report net gain/loss\n\n\
+Commands:\n\
+  balance  [REGEXP]...   show balance totals for matching accounts\n\
+  register [REGEXP]...   show register of matching transactions\n\
+  print    [REGEXP]...   print all matching entries\n\
+  xml      [REGEXP]...   print matching entries in XML format\n\
+  equity   [REGEXP]...   output equity entries for matching accounts\n\
+  prices   [REGEXP]...   display price history for matching commodities\n\
+  entry DATE PAYEE AMT   output a derived entry, based on the arguments\n";
+}
+
+void option_help(std::ostream& out)
+{
+  out << "usage: ledger [options] COMMAND [ACCT REGEX]... [-- [PAYEE REGEX]...]\n\n\
+Use -H to see all the help text on one page, or:\n\
+      --help-calc        calculation options\n\
+      --help-disp        display options\n\
+      --help-comm        commodity options\n\n\
+Basic options:\n\
+  -h, --help             display this help text\n\
+  -v, --version          show version information\n\
+  -f, --file FILE        read ledger data from FILE\n\
+  -o, --output FILE      write output to FILE\n\
+  -i, --init-file FILE   initialize ledger using FILE (default: ~/.ledgerrc)\n\
+      --cache FILE       use FILE as a binary cache when --file is not used\n\
+      --no-cache         don't use a cache, even if it would be appropriate\n\
+  -a, --account NAME     use NAME for the default account (useful with QIF)\n\n\
+Commands:\n\
+  balance  [REGEXP]...   show balance totals for matching accounts\n\
+  register [REGEXP]...   show register of matching transactions\n\
+  print    [REGEXP]...   print all matching entries\n\
+  xml      [REGEXP]...   print matching entries in XML format\n\
+  equity   [REGEXP]...   output equity entries for matching accounts\n\
+  prices   [REGEXP]...   display price history for matching commodities\n\
+  entry DATE PAYEE AMT   output a derived entry, based on the arguments\n";
+}
+
+void option_calc_help(std::ostream& out)
+{
+  out << "Options to control how a report is calculated:\n\
+  -c, --current          show only current and past entries (not future)\n\
+  -b, --begin DATE       set report begin date\n\
+  -e, --end DATE         set report end date\n\
+  -p, --period STR       report using the given period\n\
+      --period-sort EXPR sort each report period's entries by EXPR\n\
+  -C, --cleared          consider only cleared transactions\n\
+  -U, --uncleared        consider only uncleared transactions\n\
+  -R, --real             consider only real (non-virtual) transactions\n\
+  -L, --actual           consider only actual (non-automated) transactions\n\
+  -r, --related          calculate report using related transactions\n\
+      --budget           generate budget entries based on FILE\n\
+      --add-budget       show all transactions plus the budget\n\
+      --unbudgeted       show only unbudgeted transactions\n\
+      --forecast EXPR    generate forecast entries while EXPR is true\n\
+  -l, --limit EXPR       calculate only transactions matching EXPR\n\
+  -t, --amount EXPR      use EXPR to calculate the displayed amount\n\
+  -T, --total EXPR       use EXPR to calculate the displayed total\n";
+}
+
+void option_disp_help(std::ostream& out)
+{
+  out << "Output to control how report results are displayed:\n\
+  -n, --collapse         register: collapse entries; balance: no grand total\n\
+  -s, --subtotal         balance: show sub-accounts; other: show subtotals\n\
+  -P, --by-payee         show summarized totals by payee\n\
+  -x, --comm-as-payee    set commodity name as the payee, for reporting\n\
+  -E, --empty            balance: show accounts with zero balance\n\
+  -W, --weekly           show weekly sub-totals\n\
+  -M, --monthly          show monthly sub-totals\n\
+  -Y, --yearly           show yearly sub-totals\n\
+      --dow              show a days-of-the-week report\n\
+  -S, --sort EXPR        sort report according to the value expression EXPR\n\
+  -w, --wide             for the default register report, use 132 columns\n\
+      --head COUNT       show only the first COUNT entries (negative inverts)\n\
+      --tail COUNT       show only the last COUNT entries (negative inverts)\n\
+      --pager PAGER      send all output through the given PAGER program\n\
+  -A, --average          report average transaction amount\n\
+  -D, --deviation        report deviation from the average\n\
+  -%, --percentage       report balance totals as a percentile of the parent\n\
+      --totals           in the \"xml\" report, include running total\n\
+  -j, --amount-data      print only raw amount data (useful for scripting)\n\
+  -J, --total-data       print only raw total data\n\
+  -d, --display EXPR     display only transactions matching EXPR\n\
+  -y, --date-format STR  use STR as the date format (default: %Y/%m/%d)\n\
+  -F, --format STR       use STR as the format; for each report type, use:\n\
+      --balance-format      --register-format       --print-format\n\
+      --plot-amount-format  --plot-total-format     --equity-format\n\
+      --prices-format       --wide-register-format\n";
+}
+
+void option_comm_help(std::ostream& out)
+{
+  out << "Options to control how commodity values are determined:\n\
+      --price-db FILE    sets the price database to FILE (def: ~/.pricedb)\n\
+  -Z, --price-exp MINS   download quotes only if newer than MINS (def: 1440)\n\
+  -Q, --download         download price information when needed\n\
+  -O, --quantity         report commodity totals (this is the default)\n\
+  -B, --basis            report cost basis of commodities\n\
+  -V, --market           report last known market value\n\
+  -g, --performance      report gain/loss for each displayed transaction\n\
+  -G, --gain             report net gain/loss\n";
+}
+
+//////////////////////////////////////////////////////////////////////
+//
+// Basic options
+
+OPT_BEGIN(full_help, "H") {
+  option_full_help(std::cout);
+  throw 0;
+} OPT_END(full_help);
+
+OPT_BEGIN(help, "h") {
+  option_help(std::cout);
+  throw 0;
+} OPT_END(help);
+
+OPT_BEGIN(help_calc, "") {
+  option_calc_help(std::cout);
+  throw 0;
+} OPT_END(help_calc);
+
+OPT_BEGIN(help_disp, "") {
+  option_disp_help(std::cout);
+  throw 0;
+} OPT_END(help_disp);
+
+OPT_BEGIN(help_comm, "") {
+  option_comm_help(std::cout);
+  throw 0;
+} OPT_END(help_comm);
+
+OPT_BEGIN(version, "v") {
+  show_version(std::cout);
+  throw 0;
+} OPT_END(version);
+
+OPT_BEGIN(init_file, "i:") {
+  std::string path = resolve_path(optarg);
+  if (access(path.c_str(), R_OK) != -1)
+    config->init_file = path;
+  else
+    throw new error(std::string("The init file '") + path +
+		    "' does not exist or is not readable");
+} OPT_END(init_file);
+
+OPT_BEGIN(file, "f:") {
+  if (std::string(optarg) == "-") {
+    config->data_file = optarg;
+  } else {
+    std::string path = resolve_path(optarg);
+    if (access(path.c_str(), R_OK) != -1)
+      config->data_file = path;
+    else
+      throw new error(std::string("The ledger file '") + path +
+		      "' does not exist or is not readable");
+  }
+} OPT_END(file);
+
+OPT_BEGIN(cache, ":") {
+  config->cache_file = resolve_path(optarg);
+} OPT_END(cache);
+
+OPT_BEGIN(no_cache, "") {
+  config->cache_file = "<none>";
+} OPT_END(no_cache);
+
+OPT_BEGIN(output, "o:") {
+  if (std::string(optarg) != "-") {
+    std::string path = resolve_path(optarg);
+    report->output_file = path;
+  }
+} OPT_END(output);
+
+OPT_BEGIN(account, "a:") {
+  config->account = optarg;
+} OPT_END(account);
+
+OPT_BEGIN(debug, ":") {
+  config->debug_mode = true;
+  ::setenv("DEBUG_CLASS", optarg, 1);
+} OPT_END(debug);
+
+OPT_BEGIN(verbose, "") {
+  config->verbose_mode = true;
+} OPT_END(verbose);
+
+OPT_BEGIN(trace, "") {
+  config->trace_mode = true;
+} OPT_END(trace);
+
+//////////////////////////////////////////////////////////////////////
+//
+// Report filtering
+
+OPT_BEGIN(effective, "") {
+  transaction_t::use_effective_date = true;
+} OPT_END(effective);
+
+OPT_BEGIN(begin, "b:") {
+  char buf[128];
+  interval_t interval(optarg);
+  if (interval.begin)
+    std::strftime(buf, 127, formats[0], std::localtime(&interval.begin));
+  else
+    throw new error(std::string("Could not determine beginning of period '") +
+		    optarg + "'");
+
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "d>=[";
+  report->predicate += buf;
+  report->predicate += "]";
+} OPT_END(begin);
+
+OPT_BEGIN(end, "e:") {
+  char buf[128];
+  interval_t interval(optarg);
+  if (interval.end)
+    std::strftime(buf, 127, formats[0], std::localtime(&interval.end));
+  else
+    throw new error(std::string("Could not determine end of period '") +
+		    optarg + "'");
+
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "d<[";
+  report->predicate += buf;
+  report->predicate += "]";
+
+  terminus = interval.end;
+} OPT_END(end);
+
+OPT_BEGIN(current, "c") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "d<=m";
+} OPT_END(current);
+
+OPT_BEGIN(cleared, "C") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "X";
+} OPT_END(cleared);
+
+OPT_BEGIN(uncleared, "U") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "!X";
+} OPT_END(uncleared);
+
+OPT_BEGIN(real, "R") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "R";
+} OPT_END(real);
+
+OPT_BEGIN(actual, "L") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "L";
+} OPT_END(actual);
+
+OPT_BEGIN(lots, "") {
+  report->keep_price =
+  report->keep_date  =
+  report->keep_tag   = true;
+} OPT_END(lots);
+
+OPT_BEGIN(lot_prices, "") {
+  report->keep_price = true;
+} OPT_END(lots_prices);
+
+OPT_BEGIN(lot_dates, "") {
+  report->keep_date = true;
+} OPT_END(lots_dates);
+
+OPT_BEGIN(lot_tags, "") {
+  report->keep_tag = true;
+} OPT_END(lots_tags);
+
+//////////////////////////////////////////////////////////////////////
+//
+// Output customization
+
+OPT_BEGIN(format, "F:") {
+  report->format_string = optarg;
+} OPT_END(format);
+
+OPT_BEGIN(date_format, "y:") {
+  report->date_format = optarg;
+} OPT_END(date_format);
+
+OPT_BEGIN(input_date_format, ":") {
+  std::strcpy(input_format, optarg);
+  formats[0] = input_format;
+} OPT_END(input_date_format);
+
+OPT_BEGIN(balance_format, ":") {
+  config->balance_format = optarg;
+} OPT_END(balance_format);
+
+OPT_BEGIN(register_format, ":") {
+  config->register_format = optarg;
+} OPT_END(register_format);
+
+OPT_BEGIN(wide_register_format, ":") {
+  config->wide_register_format = optarg;
+} OPT_END(wide_register_format);
+
+OPT_BEGIN(csv_register_format, ":") {
+  config->csv_register_format = optarg;
+} OPT_END(csv_register_format);
+
+OPT_BEGIN(plot_amount_format, ":") {
+  config->plot_amount_format = optarg;
+} OPT_END(plot_amount_format);
+
+OPT_BEGIN(plot_total_format, ":") {
+  config->plot_total_format = optarg;
+} OPT_END(plot_total_format);
+
+OPT_BEGIN(print_format, ":") {
+  config->print_format = optarg;
+} OPT_END(print_format);
+
+OPT_BEGIN(write_hdr_format, ":") {
+  config->write_hdr_format = optarg;
+} OPT_END(write_hdr_format);
+
+OPT_BEGIN(write_xact_format, ":") {
+  config->write_xact_format = optarg;
+} OPT_END(write_xact_format);
+
+OPT_BEGIN(equity_format, ":") {
+  config->equity_format = optarg;
+} OPT_END(equity_format);
+
+OPT_BEGIN(prices_format, ":") {
+  config->prices_format = optarg;
+} OPT_END(prices_format);
+
+OPT_BEGIN(wide, "w") {
+  config->register_format = config->wide_register_format;
+} OPT_END(wide);
+
+OPT_BEGIN(head, ":") {
+  report->head_entries = std::atoi(optarg);
+} OPT_END(head);
+
+OPT_BEGIN(tail, ":") {
+  report->tail_entries = std::atoi(optarg);
+} OPT_END(tail);
+
+OPT_BEGIN(pager, ":") {
+  config->pager = optarg;
+} OPT_END(pager);
+
+OPT_BEGIN(empty, "E") {
+  report->show_empty = true;
+} OPT_END(empty);
+
+OPT_BEGIN(collapse, "n") {
+  report->show_collapsed = true;
+} OPT_END(collapse);
+
+OPT_BEGIN(subtotal, "s") {
+  report->show_subtotal = true;
+} OPT_END(subtotal);
+
+OPT_BEGIN(totals, "") {
+  report->show_totals = true;
+} OPT_END(totals);
+
+OPT_BEGIN(sort, "S:") {
+  report->sort_string = optarg;
+} OPT_END(sort);
+
+OPT_BEGIN(sort_entries, "") {
+  report->sort_string = optarg;
+  report->entry_sort = true;
+} OPT_END(sort_entries);
+
+OPT_BEGIN(sort_all, "") {
+  report->sort_string = optarg;
+  report->entry_sort = false;
+  report->sort_all   = true;
+} OPT_END(sort_all);
+
+OPT_BEGIN(period_sort, ":") {
+  report->sort_string = optarg;
+  report->entry_sort = true;
+} OPT_END(period_sort);
+
+OPT_BEGIN(related, "r") {
+  report->show_related = true;
+} OPT_END(related);
+
+OPT_BEGIN(descend, "") {
+  std::string arg(optarg);
+  std::string::size_type beg = 0;
+  report->descend_expr = "";
+  for (std::string::size_type pos = arg.find(';');
+       pos != std::string::npos;
+       beg = pos + 1, pos = arg.find(';', beg))
+    report->descend_expr += (std::string("t=={") +
+			     std::string(arg, beg, pos) + "};");
+  report->descend_expr += (std::string("t=={") +
+			   std::string(arg, beg) + "}");
+} OPT_END(descend);
+
+OPT_BEGIN(descend_if, "") {
+  report->descend_expr = optarg;
+} OPT_END(descend_if);
+
+OPT_BEGIN(period, "p:") {
+  if (report->report_period.empty()) {
+    report->report_period = optarg;
+  } else {
+    report->report_period += " ";
+    report->report_period += optarg;
+  }
+
+  // If the period gives a beginning and/or ending date, make sure to
+  // modify the calculation predicate (via the --begin and --end
+  // options) to take this into account.
+
+  char buf[128];
+  interval_t interval(report->report_period);
+
+  if (interval.begin) {
+    std::strftime(buf, 127, formats[0], std::localtime(&interval.begin));
+
+    if (! report->predicate.empty())
+      report->predicate += "&";
+    report->predicate += "d>=[";
+    report->predicate += buf;
+    report->predicate += "]";
+  }
+
+  if (interval.end) {
+    std::strftime(buf, 127, formats[0], std::localtime(&interval.end));
+
+    if (! report->predicate.empty())
+      report->predicate += "&";
+    report->predicate += "d<[";
+    report->predicate += buf;
+    report->predicate += "]";
+
+    terminus = interval.end;
+  }
+} OPT_END(period);
+
+OPT_BEGIN(daily, "") {
+  if (report->report_period.empty())
+    report->report_period = "daily";
+  else
+    report->report_period = std::string("daily ") + report->report_period;
+} OPT_END(daily);
+
+OPT_BEGIN(weekly, "W") {
+  if (report->report_period.empty())
+    report->report_period = "weekly";
+  else
+    report->report_period = std::string("weekly ") + report->report_period;
+} OPT_END(weekly);
+
+OPT_BEGIN(monthly, "M") {
+  if (report->report_period.empty())
+    report->report_period = "monthly";
+  else
+    report->report_period = std::string("monthly ") + report->report_period;
+} OPT_END(monthly);
+
+OPT_BEGIN(yearly, "Y") {
+  if (report->report_period.empty())
+    report->report_period = "yearly";
+  else
+    report->report_period = std::string("yearly ") + report->report_period;
+} OPT_END(yearly);
+
+OPT_BEGIN(dow, "") {
+  report->days_of_the_week = true;
+} OPT_END(dow);
+
+OPT_BEGIN(by_payee, "P") {
+  report->by_payee = true;
+} OPT_END(by_payee);
+
+OPT_BEGIN(comm_as_payee, "x") {
+  report->comm_as_payee = true;
+} OPT_END(comm_as_payee);
+
+OPT_BEGIN(code_as_payee, "") {
+  report->code_as_payee = true;
+} OPT_END(code_as_payee);
+
+OPT_BEGIN(budget, "") {
+  report->budget_flags = BUDGET_BUDGETED;
+} OPT_END(budget);
+
+OPT_BEGIN(add_budget, "") {
+  report->budget_flags = BUDGET_BUDGETED | BUDGET_UNBUDGETED;
+} OPT_END(add_budget);
+
+OPT_BEGIN(unbudgeted, "") {
+  report->budget_flags = BUDGET_UNBUDGETED;
+} OPT_END(unbudgeted);
+
+OPT_BEGIN(forecast, ":") {
+  report->forecast_limit = optarg;
+} OPT_END(forecast);
+
+OPT_BEGIN(reconcile, ":") {
+  report->reconcile_balance = optarg;
+} OPT_END(reconcile);
+
+OPT_BEGIN(reconcile_date, ":") {
+  report->reconcile_date = optarg;
+} OPT_END(reconcile_date);
+
+OPT_BEGIN(limit, "l:") {
+  if (! report->predicate.empty())
+    report->predicate += "&";
+  report->predicate += "(";
+  report->predicate += optarg;
+  report->predicate += ")";
+} OPT_END(limit);
+
+OPT_BEGIN(only, ":") {
+  if (! report->secondary_predicate.empty())
+    report->secondary_predicate += "&";
+  report->secondary_predicate += "(";
+  report->secondary_predicate += optarg;
+  report->secondary_predicate += ")";
+} OPT_END(only);
+
+OPT_BEGIN(display, "d:") {
+  if (! report->display_predicate.empty())
+    report->display_predicate += "&";
+  report->display_predicate += "(";
+  report->display_predicate += optarg;
+  report->display_predicate += ")";
+} OPT_END(display);
+
+OPT_BEGIN(amount, "t:") {
+  ledger::amount_expr = optarg;
+} OPT_END(amount);
+
+OPT_BEGIN(total, "T:") {
+  ledger::total_expr = optarg;
+} OPT_END(total);
+
+OPT_BEGIN(amount_data, "j") {
+  report->format_string = config->plot_amount_format;
+} OPT_END(amount_data);
+
+OPT_BEGIN(total_data, "J") {
+  report->format_string = config->plot_total_format;
+} OPT_END(total_data);
+
+OPT_BEGIN(ansi, "") {
+  format_t::ansi_codes  = true;
+  format_t::ansi_invert = false;
+} OPT_END(ansi);
+
+OPT_BEGIN(ansi_invert, "") {
+  format_t::ansi_codes  =
+  format_t::ansi_invert = true;
+} OPT_END(ansi);
+
+//////////////////////////////////////////////////////////////////////
+//
+// Commodity reporting
+
+OPT_BEGIN(base, ":") {
+  amount_t::keep_base = true;
+} OPT_END(base);
+
+OPT_BEGIN(price_db, ":") {
+  config->price_db = optarg;
+} OPT_END(price_db);
+
+OPT_BEGIN(price_exp, "Z:") {
+  report->pricing_leeway = std::atol(optarg) * 60;
+} OPT_END(price_exp);
+
+OPT_BEGIN(download, "Q") {
+  config->download_quotes = true;
+} OPT_END(download);
+
+OPT_BEGIN(quantity, "O") {
+  ledger::amount_expr = "@a";
+  ledger::total_expr  = "@O";
+} OPT_END(quantity);
+
+OPT_BEGIN(basis, "B") {
+  ledger::amount_expr = "@b";
+  ledger::total_expr  = "@B";
+} OPT_END(basis);
+
+OPT_BEGIN(price, "I") {
+  ledger::amount_expr = "@i";
+  ledger::total_expr  = "@I";
+} OPT_END(price);
+
+OPT_BEGIN(market, "V") {
+  report->show_revalued = true;
+
+  ledger::amount_expr = "@v";
+  ledger::total_expr  = "@V";
+} OPT_END(market);
+
+namespace {
+  void parse_price_setting(const char * optarg)
+  {
+    char * equals = std::strchr(optarg, '=');
+    if (! equals)
+      return;
+
+    while (std::isspace(*optarg))
+      optarg++;
+    while (equals > optarg && std::isspace(*(equals - 1)))
+      equals--;
+
+    std::string symbol(optarg, 0, equals - optarg);
+    amount_t price(equals + 1);
+
+    if (commodity_t * commodity = commodity_t::find_or_create(symbol)) {
+      commodity->add_price(now, price);
+      commodity->history()->bogus_time = now;
+    }
+  }
+}
+
+OPT_BEGIN(set_price, ":") {
+  std::string arg(optarg);
+  std::string::size_type beg = 0;
+  for (std::string::size_type pos = arg.find(';');
+       pos != std::string::npos;
+       beg = pos + 1, pos = arg.find(';', beg))
+    parse_price_setting(std::string(arg, beg, pos).c_str());
+  parse_price_setting(std::string(arg, beg).c_str());
+} OPT_END(set_price);
+
+OPT_BEGIN(performance, "g") {
+  ledger::amount_expr = "@P(@a,@m)-@b";
+  ledger::total_expr  = "@P(@O,@m)-@B";
+} OPT_END(performance);
+
+OPT_BEGIN(gain, "G") {
+  report->show_revalued      =
+  report->show_revalued_only = true;
+
+  ledger::amount_expr = "@a";
+  ledger::total_expr  = "@G";
+} OPT_END(gain);
+
+static std::string expand_value_expr(const std::string& tmpl,
+				     const std::string& expr)
+{
+  std::string xp = tmpl;
+  for (std::string::size_type i = xp.find('#');
+       i != std::string::npos;
+       i = xp.find('#'))
+    xp = (std::string(xp, 0, i) + "(" + expr + ")" +
+	  std::string(xp, i + 1));
+  return xp;
+}
+
+OPT_BEGIN(average, "A") {
+  ledger::total_expr = expand_value_expr("@A(#)", ledger::total_expr.expr);
+} OPT_END(average);
+
+OPT_BEGIN(deviation, "D") {
+  ledger::total_expr = expand_value_expr("@t-@A(#)", ledger::total_expr.expr);
+} OPT_END(deviation);
+
+OPT_BEGIN(percentage, "%") {
+  ledger::total_expr = expand_value_expr("^#&{100.0%}*(#/^#)",
+					 ledger::total_expr.expr);
+} OPT_END(percentage);
+
+//////////////////////////////////////////////////////////////////////
+
+option_t config_options[CONFIG_OPTIONS_SIZE] = {
+  { "account", 'a', true, opt_account, false },
+  { "actual", 'L', false, opt_actual, false },
+  { "add-budget", '\0', false, opt_add_budget, false },
+  { "amount", 't', true, opt_amount, false },
+  { "amount-data", 'j', false, opt_amount_data, false },
+  { "ansi", '\0', false, opt_ansi, false },
+  { "ansi-invert", '\0', false, opt_ansi_invert, false },
+  { "average", 'A', false, opt_average, false },
+  { "balance-format", '\0', true, opt_balance_format, false },
+  { "base", '\0', false, opt_base, false },
+  { "basis", 'B', false, opt_basis, false },
+  { "begin", 'b', true, opt_begin, false },
+  { "budget", '\0', false, opt_budget, false },
+  { "by-payee", 'P', false, opt_by_payee, false },
+  { "cache", '\0', true, opt_cache, false },
+  { "cleared", 'C', false, opt_cleared, false },
+  { "code-as-payee", '\0', false, opt_code_as_payee, false },
+  { "collapse", 'n', false, opt_collapse, false },
+  { "comm-as-payee", 'x', false, opt_comm_as_payee, false },
+  { "csv-register-format", '\0', true, opt_csv_register_format, false },
+  { "current", 'c', false, opt_current, false },
+  { "daily", '\0', false, opt_daily, false },
+  { "date-format", 'y', true, opt_date_format, false },
+  { "debug", '\0', true, opt_debug, false },
+  { "descend", '\0', true, opt_descend, false },
+  { "descend-if", '\0', true, opt_descend_if, false },
+  { "deviation", 'D', false, opt_deviation, false },
+  { "display", 'd', true, opt_display, false },
+  { "dow", '\0', false, opt_dow, false },
+  { "download", 'Q', false, opt_download, false },
+  { "effective", '\0', false, opt_effective, false },
+  { "empty", 'E', false, opt_empty, false },
+  { "end", 'e', true, opt_end, false },
+  { "equity-format", '\0', true, opt_equity_format, false },
+  { "file", 'f', true, opt_file, false },
+  { "forecast", '\0', true, opt_forecast, false },
+  { "format", 'F', true, opt_format, false },
+  { "full-help", 'H', false, opt_full_help, false },
+  { "gain", 'G', false, opt_gain, false },
+  { "head", '\0', true, opt_head, false },
+  { "help", 'h', false, opt_help, false },
+  { "help-calc", '\0', false, opt_help_calc, false },
+  { "help-comm", '\0', false, opt_help_comm, false },
+  { "help-disp", '\0', false, opt_help_disp, false },
+  { "init-file", 'i', true, opt_init_file, false },
+  { "input-date-format", '\0', true, opt_input_date_format, false },
+  { "limit", 'l', true, opt_limit, false },
+  { "lot-dates", '\0', false, opt_lot_dates, false },
+  { "lot-prices", '\0', false, opt_lot_prices, false },
+  { "lot-tags", '\0', false, opt_lot_tags, false },
+  { "lots", '\0', false, opt_lots, false },
+  { "market", 'V', false, opt_market, false },
+  { "monthly", 'M', false, opt_monthly, false },
+  { "no-cache", '\0', false, opt_no_cache, false },
+  { "only", '\0', true, opt_only, false },
+  { "output", 'o', true, opt_output, false },
+  { "pager", '\0', true, opt_pager, false },
+  { "percentage", '%', false, opt_percentage, false },
+  { "performance", 'g', false, opt_performance, false },
+  { "period", 'p', true, opt_period, false },
+  { "period-sort", '\0', true, opt_period_sort, false },
+  { "plot-amount-format", '\0', true, opt_plot_amount_format, false },
+  { "plot-total-format", '\0', true, opt_plot_total_format, false },
+  { "price", 'I', false, opt_price, false },
+  { "price-db", '\0', true, opt_price_db, false },
+  { "price-exp", 'Z', true, opt_price_exp, false },
+  { "prices-format", '\0', true, opt_prices_format, false },
+  { "print-format", '\0', true, opt_print_format, false },
+  { "quantity", 'O', false, opt_quantity, false },
+  { "real", 'R', false, opt_real, false },
+  { "reconcile", '\0', true, opt_reconcile, false },
+  { "reconcile-date", '\0', true, opt_reconcile_date, false },
+  { "register-format", '\0', true, opt_register_format, false },
+  { "related", 'r', false, opt_related, false },
+  { "set-price", '\0', true, opt_set_price, false },
+  { "sort", 'S', true, opt_sort, false },
+  { "sort-all", '\0', true, opt_sort_all, false },
+  { "sort-entries", '\0', true, opt_sort_entries, false },
+  { "subtotal", 's', false, opt_subtotal, false },
+  { "tail", '\0', true, opt_tail, false },
+  { "total", 'T', true, opt_total, false },
+  { "total-data", 'J', false, opt_total_data, false },
+  { "totals", '\0', false, opt_totals, false },
+  { "trace", '\0', false, opt_trace, false },
+  { "unbudgeted", '\0', false, opt_unbudgeted, false },
+  { "uncleared", 'U', false, opt_uncleared, false },
+  { "verbose", '\0', false, opt_verbose, false },
+  { "version", 'v', false, opt_version, false },
+  { "weekly", 'W', false, opt_weekly, false },
+  { "wide", 'w', false, opt_wide, false },
+  { "wide-register-format", '\0', true, opt_wide_register_format, false },
+  { "write-hdr-format", '\0', true, opt_write_hdr_format, false },
+  { "write-xact-format", '\0', true, opt_write_xact_format, false },
+  { "yearly", 'Y', false, opt_yearly, false },
+};
+
+} // namespace ledger

option.h

@@ -30,4 +30,24 @@ void process_arguments(option_t * options, int argc, char ** argv,
 void process_environment(option_t * options, char ** envp,
 			 const std::string& tag);
 
+namespace ledger {
+
+class config_t;
+class report_t;
+
+extern config_t * config;
+extern report_t * report;
+
+#define CONFIG_OPTIONS_SIZE 94
+extern option_t config_options[CONFIG_OPTIONS_SIZE];
+
+void option_help(std::ostream& out);
+
+#define OPT_BEGIN(tag, chars)			\
+    void opt_ ## tag(const char * optarg)
+
+#define OPT_END(tag)
+
+} // namespace ledger
+
 #endif // _OPTION_H

parser.cc

@@ -168,6 +168,7 @@ unsigned int parse_ledger_data(config_t&   config,
       config.use_cache = false;
       journal->sources.push_back("<stdin>");
 #if 0
+      // jww (2006-03-23): Why doesn't XML work on stdin?
       if (xml_parser && std::cin.peek() == '<')
 	entry_count += xml_parser->parse(std::cin, config, journal,
 					 acct);

textual.cc

@@ -64,10 +64,11 @@ inline char * next_element(char * buf, bool variable = false)
   return NULL;
 }
 
-value_expr parse_amount_expr(std::istream& in, amount_t& amount,
+static value_expr parse_amount_expr(std::istream& in, amount_t& amount,
-			     transaction_t * xact)
+				    transaction_t * xact,
+				    unsigned short flags = 0)
 {
-  value_expr expr(parse_value_expr(in, NULL, PARSE_VALEXPR_RELAXED |
+  value_expr expr(parse_value_expr(in, NULL, flags | PARSE_VALEXPR_RELAXED |
 				   PARSE_VALEXPR_PARTIAL)->acquire());
 
   DEBUG_PRINT("ledger.textual.parse", "line " << linenum << ": " <<
@@ -213,8 +214,10 @@ transaction_t * parse_transaction(char * line, account_t * account,
 	try {
 	  unsigned long beg = (long)in.tellg();
 
-	  if (parse_amount_expr(in, *xact->cost, xact.get()))
+	  if (parse_amount_expr(in, *xact->cost, xact.get(),
-	    throw new parse_error("A transaction's cost must evalute to a constant value");
+				PARSE_VALEXPR_NO_MIGRATE))
+	    throw new parse_error
+	      ("A transaction's cost must evalute to a constant value");
 
 	  unsigned long end = (long)in.tellg();
 
@@ -700,7 +703,7 @@ unsigned int textual_parser_t::parse(std::istream&	 in,
 	  if (p)
 	    *p++ = '\0';
 	}
-	config.process_option(line + 2, p);
+	process_option(config_options, line + 2, p);
 	break;
       }
 

valexpr.cc

@@ -772,7 +772,8 @@ value_expr_t * parse_value_term(std::istream& in, scope_t * scope,
       // the current maximum precision displayed.
       try {
 	pos = (long)in.tellg();
-	temp.parse(in);
+	temp.parse(in, flags & PARSE_VALEXPR_NO_MIGRATE ?
+		   AMOUNT_PARSE_NO_MIGRATE : 0);
       }
       catch (amount_error * err) {
 	// If the amount had no commodity, it must be an unambiguous

valexpr.h

@@ -276,9 +276,10 @@ bool compute_amount(value_expr_t * expr, amount_t& amt,
 		    const transaction_t * xact,
 		    value_expr_t * context = NULL);
 
-#define PARSE_VALEXPR_NORMAL  0x00
+#define PARSE_VALEXPR_NORMAL	 0x00
-#define PARSE_VALEXPR_PARTIAL 0x01
+#define PARSE_VALEXPR_PARTIAL	 0x01
-#define PARSE_VALEXPR_RELAXED 0x02
+#define PARSE_VALEXPR_RELAXED	 0x02
+#define PARSE_VALEXPR_NO_MIGRATE 0x04
 
 value_expr_t * parse_value_expr(std::istream& in,
 				scope_t * scope = NULL,

value.cc

@@ -1129,6 +1129,25 @@ value_t value_t::value(const std::time_t moment) const
   }
 }
 
+void value_t::reduce()
+{
+  switch (type) {
+  case BOOLEAN:
+  case DATETIME:
+  case INTEGER:
+    break;
+  case AMOUNT:
+    ((amount_t *) data)->reduce();
+    break;
+  case BALANCE:
+    ((balance_t *) data)->reduce();
+    break;
+  case BALANCE_PAIR:
+    ((balance_pair_t *) data)->reduce();
+    break;
+  }
+}
+
 void value_t::round()
 {
   switch (type) {

value.h

@@ -316,6 +316,14 @@ class value_t
 
   value_t& add(const amount_t&  amount, const amount_t * cost = NULL);
   value_t  value(const std::time_t moment) const;
+  void     reduce();
+
+  value_t reduced() const {
+    value_t temp(*this);
+    temp.reduce();
+    return temp;
+  }
+
   void     round();
   value_t  unround() const;
 };

walk.cc

@@ -17,12 +17,14 @@ bool compare_items<transaction_t>::operator()(const transaction_t * left,
   transaction_xdata_t& lxdata(transaction_xdata(*left));
   if (! (lxdata.dflags & TRANSACTION_SORT_CALC)) {
     guarded_compute(sort_order, lxdata.sort_value, details_t(*left));
+    lxdata.sort_value.reduce();
     lxdata.dflags |= TRANSACTION_SORT_CALC;
   }
 
   transaction_xdata_t& rxdata(transaction_xdata(*right));
   if (! (rxdata.dflags & TRANSACTION_SORT_CALC)) {
     guarded_compute(sort_order, rxdata.sort_value, details_t(*right));
+    rxdata.sort_value.reduce();
     rxdata.dflags |= TRANSACTION_SORT_CALC;
   }