sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Parsing now works again. And there was much rejoicing.

Browse source
This commit is contained in:
John Wiegley 2008-07-24 11:36:40 -04:00
parent 171f79dda2
commit ee39695722
11 changed files with 365 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
amount.cc
View file

@ -855,19 +855,18 @@ bool amount_t::commodity_annotated() const
return commodity().annotated;
}
annotation_t amount_t::annotation_details() const
annotation_t& amount_t::annotation_details()
{
if (! quantity)
throw_(amount_error,
"Cannot return commodity annotation details of an uninitialized amount");
assert(! commodity().annotated || as_annotated_commodity(commodity()).details);
if (! commodity().is_annotated())
throw_(amount_error,
"Request for annotation details from an unannotated amount");
if (commodity().annotated) {
annotated_commodity_t& ann_comm(as_annotated_commodity(commodity()));
return ann_comm.details;
}
return annotation_t();
annotated_commodity_t& ann_comm(as_annotated_commodity(commodity()));
return ann_comm.details;
}
amount_t amount_t::strip_annotations(const bool _keep_price,
@ -1097,8 +1096,10 @@ void amount_t::print(std::ostream& _out, bool omit_commodity,
{
assert(valid());
if (! quantity)
throw_(amount_error, "Cannot write out an uninitialized amount");
if (! quantity) {
_out << "<null>";
return;
}
amount_t base(*this);
if (! amount_t::keep_base)

17
amount.h
View file

@ -538,12 +538,17 @@ public:
* amount_t::keep_price, amount_t::keep_date and amount_t::keep_tag
* have been set to (which all default to false).
*/
void annotate_commodity(const annotation_t& details);
bool commodity_annotated() const;
annotation_t annotation_details() const;
amount_t strip_annotations(const bool _keep_price = keep_price,
const bool _keep_date = keep_date,
const bool _keep_tag = keep_tag) const;
void annotate_commodity(const annotation_t& details);
bool commodity_annotated() const;
annotation_t& annotation_details();
const annotation_t& annotation_details() const {
return const_cast<amount_t&>(*this).annotation_details();
}
amount_t strip_annotations(const bool _keep_price = keep_price,
const bool _keep_date = keep_date,
const bool _keep_tag = keep_tag) const;
/**
* Parsing methods. The method `parse' is used to parse an amount

69
commodity.cc
View file

@ -118,6 +118,75 @@ optional<amount_t> commodity_t::value(const optional<datetime_t>& moment)
return price;
}
amount_t commodity_t::exchange(const amount_t& amount,
amount_t& final_cost, // out
amount_t& basis_cost, // out
const optional<amount_t>& total_cost_,
const optional<amount_t>& per_unit_cost_,
const optional<datetime_t>& moment,
const optional<string>& tag)
{
// (assert (or (and total-cost (not per-unit-cost))
// (and per-unit-cost (not total-cost))))
assert((total_cost_ && ! per_unit_cost_) || (per_unit_cost_ && ! total_cost_));
// (let* ((commodity (amount-commodity amount))
// (current-annotation
// (and (annotated-commodity-p commodity)
// (commodity-annotation commodity)))
// (base-commodity (if (annotated-commodity-p commodity)
// (get-referent commodity)
// commodity))
// (per-unit-cost (or per-unit-cost
// (divide total-cost amount)))
// (total-cost (or total-cost
// (multiply per-unit-cost amount))))
commodity_t& commodity(amount.commodity());
annotation_t * current_annotation = NULL;
if (commodity.annotated)
current_annotation = &as_annotated_commodity(commodity).details;
commodity_t& base_commodity
(current_annotation ?
as_annotated_commodity(commodity).referent() : commodity);
amount_t per_unit_cost(per_unit_cost_ ?
*per_unit_cost_ : *total_cost_ / amount);
final_cost = total_cost_ ? *total_cost_ : *per_unit_cost_ * amount;
// Add a price history entry for this conversion if we know when it took
// place
// (if (and moment (not (commodity-no-market-price-p base-commodity)))
// (add-price base-commodity per-unit-cost moment))
if (moment && ! commodity.has_flags(COMMODITY_STYLE_NOMARKET))
base_commodity.add_price(*moment, per_unit_cost);
// ;; returns: ANNOTATED-AMOUNT TOTAL-COST BASIS-COST
// (values (annotate-commodity
// amount
// (make-commodity-annotation :price per-unit-cost
// :date moment
// :tag tag))
// total-cost
// (if current-annotation
// (multiply (annotation-price current-annotation) amount)
// total-cost))))
if (current_annotation && current_annotation->price)
basis_cost = *current_annotation->price * amount;
else
basis_cost = final_cost;
amount_t ann_amount(amount);
ann_amount.annotate_commodity(annotation_t(per_unit_cost, moment, tag));
return ann_amount;
}
commodity_t::operator bool() const
{
return this != parent().null_commodity;

12
commodity.h
View file

@ -117,6 +117,10 @@ public:
operator bool() const;
bool is_annotated() const {
return annotated;
}
virtual bool operator==(const commodity_t& comm) const {
if (comm.annotated)
return comm == *this;
@ -185,6 +189,14 @@ public:
optional<amount_t> value(const optional<datetime_t>& moment = none);
static amount_t exchange(const amount_t& amount,
amount_t& final_cost, // out
amount_t& basis_cost, // out
const optional<amount_t>& total_cost,
const optional<amount_t>& per_unit_cost = none,
const optional<datetime_t>& moment = none,
const optional<string>& tag = none);
static void parse_symbol(std::istream& in, string& symbol);
static void parse_symbol(char *& p, string& symbol);
static string parse_symbol(std::istream& in) {

320
journal.cc
View file

@ -118,185 +118,249 @@ bool entry_base_t::remove_transaction(transaction_t * xact)
bool entry_base_t::finalize()
{
// Scan through and compute the total balance for the entry. This
// is used for auto-calculating the value of entries with no cost,
// and the per-unit price of unpriced commodities.
// Scan through and compute the total balance for the entry. This is used
// for auto-calculating the value of entries with no cost, and the per-unit
// price of unpriced commodities.
value_t balance;
bool no_amounts = true;
bool saw_null = false;
// (let ((balance 0)
// null-xact)
value_t balance;
transaction_t * null_xact = NULL;
// (do-transactions (xact entry)
// (when (xact-must-balance-p xact)
// (let ((amt (xact-amount* xact)))
// (if amt
// (setf balance (add balance (or (xact-cost xact) amt)))
// (if null-xact
// (error "Only one transaction with null amount allowed ~
// per entry (beg ~S end ~S)"
// (item-position-begin-line (entry-position entry))
// (item-position-end-line (entry-position entry)))
// (setf null-xact xact))))))
//
for (transactions_list::const_iterator x = transactions.begin();
x != transactions.end();
x++) {
if (! (*x)->has_flags(TRANSACTION_VIRTUAL) ||
(*x)->has_flags(TRANSACTION_BALANCE)) {
if ((*x)->must_balance()) {
amount_t& p((*x)->cost ? *(*x)->cost : (*x)->amount);
if (! p.is_null()) {
if (no_amounts) {
if (balance.is_null())
balance = p;
no_amounts = false;
} else {
else
balance += p;
}
assert(! (*x)->amount.is_null());
if ((*x)->cost && (*x)->amount.commodity().annotated) {
annotated_commodity_t&
ann_comm(static_cast<annotated_commodity_t&>
((*x)->amount.commodity()));
if (ann_comm.details.price)
balance += (*ann_comm.details.price * (*x)->amount.number() -
*((*x)->cost));
}
} else {
saw_null = true;
if (null_xact)
throw_(std::logic_error,
"Only one transaction with null amount allowed per entry");
else
null_xact = *x;
}
}
}
assert(balance.valid());
// If it's a null entry, then let the user have their fun
if (no_amounts)
return true;
DEBUG("ledger.journal.finalize", "initial balance = " << balance);
// If there is only one transaction, balance against the basket
// account if one has been set.
// If there is only one transaction, balance against the default account if
// one has been set.
// (when (= 1 (length (entry-transactions entry)))
// (if-let ((default-account
// (journal-default-account (entry-journal entry))))
// (setf null-xact
// (make-transaction :entry entry
// :status (xact-status
// (first (entry-transactions entry)))
// :account default-account
// :generatedp t))
// (add-transaction entry null-xact)))
if (journal && journal->basket && transactions.size() == 1) {
assert(balance.is_amount());
transaction_t * nxact = new transaction_t(journal->basket);
// The amount doesn't need to be set because the code below will
// balance this transaction against the other.
add_transaction(nxact);
nxact->add_flags(TRANSACTION_CALCULATED);
// jww (2008-07-24): Need to make the rest of the code aware of what to do
// when it sees a generated transaction.
null_xact = new transaction_t(journal->basket, TRANSACTION_GENERATED);
null_xact->state = (*transactions.begin())->state;
add_transaction(null_xact);
}
// If the first transaction of a two-transaction entry is of a
// different commodity than the other, and it has no per-unit price,
// determine its price by dividing the unit count into the value of
// the balance. This is done for the last eligible commodity.
if (null_xact != NULL) {
// If one transaction has no value at all, its value will become the
// inverse of the rest. If multiple commodities are involved, multiple
// transactions are generated to balance them all.
// (progn
// (if (balance-p balance)
// (let ((first t))
// (dolist (amount (balance-amounts balance))
// (if first
// (setf (xact-amount* null-xact) (negate amount)
// first nil)
// (add-transaction
// entry
// (make-transaction :entry entry
// :account (xact-account null-xact)
// :amount (negate amount)
// :generatedp t)))))
// (setf (xact-amount* null-xact) (negate balance)
// (xact-calculatedp null-xact) t))
//
// (setf balance 0))
if (balance.is_balance()) {
bool first = true;
const balance_t& bal(balance.as_balance());
for (balance_t::amounts_map::const_iterator i = bal.amounts.begin();
i != bal.amounts.end();
i++) {
if (first) {
null_xact->amount = (*i).second.negate();
first = false;
} else {
add_transaction(new transaction_t(null_xact->account,
(*i).second.negate(),
TRANSACTION_GENERATED));
}
}
} else {
null_xact->amount = balance.as_amount().negate();
null_xact->add_flags(TRANSACTION_CALCULATED);
}
balance = NULL_VALUE;
}
else if (balance.is_balance() &&
balance.as_balance().amounts.size() == 2) {
// When an entry involves two different commodities (regardless of how
// many transactions there are) determine the conversion ratio by dividing
// the total value of one commodity by the total value of the other. This
// establishes the per-unit cost for this transaction for both
// commodities.
// (when (and (balance-p balance)
// (= 2 (balance-commodity-count balance)))
// (destructuring-bind (x y) (balance-amounts balance)
// (let ((a-commodity (amount-commodity x))
// (per-unit-cost (value-abs (divide x y))))
// (do-transactions (xact entry)
// (let ((amount (xact-amount* xact)))
// (unless (or (xact-cost xact)
// (not (xact-must-balance-p xact))
// (commodity-equal (amount-commodity amount)
// a-commodity))
// (setf balance (subtract balance amount)
// (xact-cost xact) (multiply per-unit-cost amount)
// balance (add balance (xact-cost xact))))))))))
if (! saw_null && balance && balance.is_balance()) {
const balance_t& bal(balance.as_balance());
if (bal.amounts.size() == 2) {
transactions_list::const_iterator x = transactions.begin();
assert(! (*x)->amount.is_null());
commodity_t& this_comm = (*x)->amount.commodity();
balance_t::amounts_map::const_iterator this_bal =
bal.amounts.find(&this_comm);
assert(this_bal != bal.amounts.end());
balance_t::amounts_map::const_iterator a = bal.amounts.begin();
const amount_t& x((*a++).second);
const amount_t& y((*a++).second);
balance_t::amounts_map::const_iterator other_bal =
bal.amounts.begin();
if (this_bal == other_bal)
other_bal++;
if (! y.is_realzero()) {
amount_t per_unit_cost = (x / y).abs();
amount_t per_unit_cost =
((*other_bal).second / (*this_bal).second.number()).unround();
commodity_t& comm(x.commodity());
for (; x != transactions.end(); x++) {
if ((*x)->cost || (*x)->has_flags(TRANSACTION_VIRTUAL) ||
(*x)->amount.commodity() != this_comm)
continue;
for (transactions_list::const_iterator x = transactions.begin();
x != transactions.end();
x++) {
const amount_t& x_amt((*x)->amount);
balance -= (*x)->amount;
if (! ((*x)->cost ||
! (*x)->must_balance() ||
x_amt.commodity() == comm)) {
DEBUG("ledger.journal.finalize", "before operation 1 = " << balance);
balance -= x_amt;
DEBUG("ledger.journal.finalize", "after operation 1 = " << balance);
DEBUG("ledger.journal.finalize", "x_amt = " << x_amt);
DEBUG("ledger.journal.finalize", "per_unit_cost = " << per_unit_cost);
entry_t * entry = dynamic_cast<entry_t *>(this);
(*x)->cost = per_unit_cost * x_amt;
DEBUG("ledger.journal.finalize", "*(*x)->cost = " << *(*x)->cost);
if ((*x)->amount.commodity() &&
! (*x)->amount.commodity().annotated)
(*x)->amount.annotate_commodity
(annotation_t(per_unit_cost.abs(),
entry ? entry->actual_date() : optional<datetime_t>(),
entry ? entry->code : optional<string>()));
balance += *(*x)->cost;
DEBUG("ledger.journal.finalize", "after operation 2 = " << balance);
}
(*x)->cost = - (per_unit_cost * (*x)->amount.number());
balance += *(*x)->cost;
}
}
DEBUG("ledger.journal.finalize", "resolved balance = " << balance);
}
// Walk through each of the transactions, fixing up any that we
// can, and performing any on-the-fly calculations.
// Now that the transaction list has its final form, calculate the balance
// once more in terms of total cost, accounting for any possible gain/loss
// amounts.
bool empty_allowed = true;
// (do-transactions (xact entry)
// (when (xact-cost xact)
// (let ((amount (xact-amount* xact)))
// (assert (not (commodity-equal (amount-commodity amount)
// (amount-commodity (xact-cost xact)))))
// (multiple-value-bind (annotated-amount total-cost basis-cost)
// (exchange-commodity amount :total-cost (xact-cost xact)
// :moment (entry-date entry)
// :tag (entry-code entry))
// (if (annotated-commodity-p (amount-commodity amount))
// (if-let ((price (annotation-price
// (commodity-annotation
// (amount-commodity amount)))))
// (setf balance
// (add balance (subtract basis-cost total-cost))))
// (setf (xact-amount* xact) annotated-amount))))))
for (transactions_list::const_iterator x = transactions.begin();
x != transactions.end();
x++) {
if (! (*x)->amount.is_null() ||
((*x)->has_flags(TRANSACTION_VIRTUAL) &&
! (*x)->has_flags(TRANSACTION_BALANCE)))
continue;
if ((*x)->cost) {
const amount_t& x_amt((*x)->amount);
if (! empty_allowed)
throw_(std::logic_error,
"Only one transaction with null amount allowed per entry");
empty_allowed = false;
assert(x_amt.commodity() != (*x)->cost->commodity());
// If one transaction gives no value at all, its value will become
// the inverse of the value of the others. If multiple
// commodities are involved, multiple transactions will be
// generated to balance them all.
entry_t * entry = dynamic_cast<entry_t *>(this);
const balance_t * bal = NULL;
switch (balance.type()) {
case value_t::BALANCE_PAIR:
bal = &balance.as_balance_pair().quantity();
// fall through...
// jww (2008-07-24): Pass the entry's code here if we can, as the
// auto-tag
amount_t final_cost;
amount_t basis_cost;
amount_t ann_amount =
commodity_t::exchange(x_amt, final_cost, basis_cost,
(*x)->cost, none, (*x)->actual_date(),
entry ? entry->code : optional<string>());
case value_t::BALANCE:
if (! bal)
bal = &balance.as_balance();
if (bal->amounts.size() < 2) {
balance.cast(value_t::AMOUNT);
} else {
bool first = true;
for (balance_t::amounts_map::const_iterator
i = bal->amounts.begin();
i != bal->amounts.end();
i++) {
amount_t amt = (*i).second.negate();
if (first) {
(*x)->amount = amt;
first = false;
} else {
transaction_t * nxact = new transaction_t((*x)->account);
add_transaction(nxact);
nxact->add_flags(TRANSACTION_CALCULATED);
nxact->amount = amt;
}
balance += amt;
if ((*x)->amount.commodity_annotated()) {
if (ann_amount.annotation_details().price) {
if (balance.is_null())
balance = basis_cost - final_cost;
else
balance += basis_cost - final_cost;
}
break;
} else {
(*x)->amount = ann_amount;
}
// fall through...
case value_t::AMOUNT:
(*x)->amount = balance.as_amount().negate();
(*x)->add_flags(TRANSACTION_CALCULATED);
balance += (*x)->amount;
break;
default:
break;
}
}
if (balance) {
DEBUG("ledger.journal.finalize", "final balance = " << balance);
// (if (value-zerop balance)
// (prog1
// entry
// (setf (entry-normalizedp entry) t))
// (error "Entry does not balance (beg ~S end ~S); remaining balance is:~%~A"
// (item-position-begin-line (entry-position entry))
// (item-position-end-line (entry-position entry))
// (format-value balance :width 20)))
if (! balance.is_null() && ! balance.is_zero()) {
error * err =
new balance_error("Entry does not balance",
new entry_context(*this, "While balancing entry:"));
DEBUG("ledger.journal.unbalanced_remainder", "balance = " << balance);
balance.round();
err->context.push_front
(new value_context(balance, "Unbalanced remainder is:"));

10
journal.h
View file

@ -46,6 +46,7 @@ namespace ledger {
#define TRANSACTION_AUTO 0x0004
#define TRANSACTION_BULK_ALLOC 0x0008
#define TRANSACTION_CALCULATED 0x0010
#define TRANSACTION_GENERATED 0x0020
class entry_t;
class account_t;
@ -73,8 +74,9 @@ class transaction_t : public supports_flags<>
mutable void * data;
static bool use_effective_date;
transaction_t(account_t * _account = NULL)
: supports_flags<>(TRANSACTION_NORMAL), entry(NULL),
transaction_t(account_t * _account = NULL,
unsigned int _flags = TRANSACTION_NORMAL)
: supports_flags<>(_flags), entry(NULL),
state(UNCLEARED), account(_account),
beg_pos(0), beg_line(0), end_pos(0), end_line(0), data(NULL)
{
@ -120,6 +122,10 @@ class transaction_t : public supports_flags<>
return actual_date();
}
bool must_balance() const {
return ! has_flags(TRANSACTION_VIRTUAL) || has_flags(TRANSACTION_BALANCE);
}
bool valid() const;
};

5
main.cc
View file

@ -205,12 +205,15 @@ static int read_and_report(ledger::report_t& report, int argc, char * argv[],
journal_t& journal(*session.create_journal());
if (! session.read_data(journal, report.account))
std::size_t count = session.read_data(journal, report.account);
if (count == 0)
throw_(parse_error, "Failed to locate any journal entries; "
"did you specify a valid file with -f?");
INFO_FINISH(journal);
INFO("Found " << count << " entries");
TRACE_FINISH(entry_text, 1);
TRACE_FINISH(entry_date, 1);
TRACE_FINISH(entry_details, 1);

2
report.cc
View file

@ -73,7 +73,7 @@ value_t report_t::abbrev(expr::call_scope_t& args)
return value_t(abbreviate(str, wid, style, true,
static_cast<int>(abbrev_len)), true);
#else
return value_t();
return NULL_VALUE;
#endif
}

4
valexpr.cc
View file

@ -87,7 +87,7 @@ value_t scope_t::resolve(const string& name) {
if (definition)
return definition->calc(*this);
else
return value_t();
return NULL_VALUE;
}
void symbol_scope_t::define(const string& name, ptr_op_t def)
@ -135,7 +135,7 @@ namespace {
temp.reset(expr);
} else {
temp.reset(new op_t(op_t::VALUE));
temp->set_value(value_t());
temp->set_value(NULL_VALUE);
expr->compute(temp->as_value_lval(), details, context);
}
} else {

73
value.cc
View file

@ -298,7 +298,9 @@ void value_t::in_place_simplify()
if (is_balance() && as_balance().amounts.size() == 1) {
DEBUG_("Reducing balance to amount");
DEBUG("ledger.value.reduce", "as a balance it looks like: " << *this);
in_place_cast(AMOUNT);
DEBUG("ledger.value.reduce", "as an amount it looks like: " << *this);
}
#if 0
@ -445,7 +447,7 @@ value_t& value_t::operator+=(const value_t& val)
break;
}
throw_(value_error, "Cannot add " << label() << " to " << val.label());
throw_(value_error, "Cannot add " << val.label() << " to " << label());
return *this;
}
@ -605,7 +607,7 @@ value_t& value_t::operator-=(const value_t& val)
break;
}
throw_(value_error, "Cannot subtract " << label() << " from " << val.label());
throw_(value_error, "Cannot subtract " << val.label() << " from " << label());
return *this;
}
@ -952,8 +954,7 @@ bool value_t::operator>(const value_t& val) const
break;
}
throw_(value_error,
"Cannot compare " << label() << " to " << val.label());
throw_(value_error, "Cannot compare " << label() << " to " << val.label());
return *this;
}
@ -1019,13 +1020,13 @@ void value_t::in_place_cast(type_t cast_type)
if (amt.is_null())
set_balance(balance_t());
else
set_balance(as_amount());
set_balance(as_amount()); // creates temporary
return;
case BALANCE_PAIR:
if (amt.is_null())
set_balance_pair(balance_pair_t());
else
set_balance_pair(as_amount());
set_balance_pair(as_amount()); // creates temporary
return;
case STRING:
if (amt.is_null())
@ -1044,7 +1045,10 @@ void value_t::in_place_cast(type_t cast_type)
case AMOUNT: {
const balance_t& temp(as_balance());
if (temp.amounts.size() == 1) {
set_amount((*temp.amounts.begin()).second);
// 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((*temp.amounts.begin()).second));
return;
}
else if (temp.amounts.size() == 0) {
@ -1070,7 +1074,7 @@ void value_t::in_place_cast(type_t cast_type)
case AMOUNT: {
const balance_t& temp(as_balance_pair().quantity());
if (temp.amounts.size() == 1) {
set_amount((*temp.amounts.begin()).second);
set_amount(amount_t((*temp.amounts.begin()).second));
return;
}
else if (temp.amounts.size() == 0) {
@ -1084,7 +1088,9 @@ void value_t::in_place_cast(type_t cast_type)
break;
}
case BALANCE:
set_balance(as_balance_pair().quantity());
// A temporary is required, becaues set_balance is going to wipe us out
// before assigned the value passed in.
set_balance(balance_t(as_balance_pair().quantity()));
return;
default:
break;
@ -1176,6 +1182,37 @@ bool value_t::is_realzero() const
return true;
}
bool value_t::is_zero() const
{
switch (type()) {
case BOOLEAN:
return ! as_boolean();
case INTEGER:
return as_long() == 0;
case DATETIME:
return ! is_valid(as_datetime());
case AMOUNT:
return as_amount().is_zero();
case BALANCE:
return as_balance().is_zero();
case BALANCE_PAIR:
return as_balance_pair().is_zero();
case STRING:
return as_string().empty();
case SEQUENCE:
return as_sequence().empty();
case POINTER:
return as_any_pointer().empty();
default:
assert(false);
break;
}
assert(false);
return true;
}
value_t value_t::value(const optional<datetime_t>& moment) const
{
switch (type()) {
@ -1204,7 +1241,7 @@ value_t value_t::value(const optional<datetime_t>& moment) const
}
throw_(value_error, "Cannot find the value of " << label());
return value_t();
return NULL_VALUE;
}
void value_t::in_place_reduce()
@ -1248,7 +1285,7 @@ value_t value_t::abs() const
}
throw_(value_error, "Cannot abs " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::round() const
@ -1267,7 +1304,7 @@ value_t value_t::round() const
}
throw_(value_error, "Cannot round " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::unround() const
@ -1282,7 +1319,7 @@ value_t value_t::unround() const
}
throw_(value_error, "Cannot unround " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::annotated_price() const
@ -1300,7 +1337,7 @@ value_t value_t::annotated_price() const
}
throw_(value_error, "Cannot find the annotated price of " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::annotated_date() const
@ -1321,7 +1358,7 @@ value_t value_t::annotated_date() const
}
throw_(value_error, "Cannot find the annotated date of " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::annotated_tag() const
@ -1342,7 +1379,7 @@ value_t value_t::annotated_tag() const
}
throw_(value_error, "Cannot find the annotated tag of " << label());
return value_t();
return NULL_VALUE;
}
value_t value_t::strip_annotations(const bool keep_price,
@ -1378,7 +1415,7 @@ value_t value_t::strip_annotations(const bool keep_price,
break;
}
assert(false);
return value_t();
return NULL_VALUE;
}
value_t value_t::cost() const
@ -1401,7 +1438,7 @@ value_t value_t::cost() const
}
throw_(value_error, "Cannot find the cost of " << label());
return value_t();
return NULL_VALUE;
}
value_t& value_t::add(const amount_t& amount, const optional<amount_t>& tcost)

1
value.h
View file

@ -400,6 +400,7 @@ public:
operator bool() const;
bool is_realzero() const;
bool is_zero() const;
bool is_null() const {
if (! storage) {
return true;