480 lines
12 KiB
C++
480 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2003-2007, John Wiegley. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* - Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* - Neither the name of New Artisans LLC nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "textual.h"
|
|
|
|
namespace ledger {
|
|
|
|
using namespace xml;
|
|
|
|
#define MAX_LINE 1024
|
|
|
|
typedef builder_t::position_t position_t;
|
|
|
|
void parse_transaction(builder_t& builder,
|
|
char * line,
|
|
position_t& end_of_line)
|
|
{
|
|
// First cut up the input line into its various parts.
|
|
|
|
char * state = NULL;
|
|
char * account_path = NULL;
|
|
char * amount = NULL;
|
|
char * note = NULL;
|
|
|
|
char * p = line;
|
|
|
|
if (*p == '*' || *p == '!')
|
|
state = p++;
|
|
|
|
account_path = skip_ws(p);
|
|
|
|
amount = next_element(account_path, true);
|
|
if (amount) {
|
|
char * p = amount;
|
|
while (*p && *p != ';')
|
|
p++;
|
|
|
|
if (*p == ';') {
|
|
*p++ = '\0';
|
|
note = skip_ws(p);
|
|
}
|
|
|
|
p = amount + (std::strlen(amount) - 1);
|
|
while (p > amount && std::isspace(*p))
|
|
p--;
|
|
|
|
if (std::isspace(*(p + 1)))
|
|
*++p = '\0';
|
|
}
|
|
|
|
// Setup the details for this node
|
|
|
|
if (state) {
|
|
switch (*state) {
|
|
case '*':
|
|
builder.push_attr(CLEARED_ATTR, "yes");
|
|
break;
|
|
case '!':
|
|
builder.push_attr(PENDING_ATTR, "yes");
|
|
break;
|
|
}
|
|
}
|
|
|
|
builder.begin_node(TRANSACTION_NODE);
|
|
|
|
// Parse the account name
|
|
|
|
char * b = &account_path[0];
|
|
char * e = &account_path[std::strlen(account_path) - 1];
|
|
if ((*b == '[' && *e == ']') ||
|
|
(*b == '(' && *e == ')')) {
|
|
builder.push_attr(VIRTUAL_ATTR, "yes");
|
|
if (*b == '[')
|
|
builder.push_attr(BALANCE_ATTR, "yes");
|
|
*account_path++ = '\0';
|
|
*e = '\0';
|
|
}
|
|
|
|
builder.begin_node(ACCOUNT_PATH_NODE, true);
|
|
builder.append_text(account_path);
|
|
builder.end_node(ACCOUNT_PATH_NODE);
|
|
|
|
// Parse the optional amount
|
|
|
|
if (amount) {
|
|
builder.begin_node(AMOUNT_EXPR_NODE, true);
|
|
builder.append_text(amount);
|
|
builder.end_node(AMOUNT_EXPR_NODE);
|
|
}
|
|
|
|
// Parse the optional note
|
|
|
|
if (note) {
|
|
builder.begin_node(NOTE_NODE, true);
|
|
builder.append_text(note);
|
|
builder.end_node(NOTE_NODE);
|
|
}
|
|
|
|
builder.end_node(TRANSACTION_NODE, end_of_line);
|
|
}
|
|
|
|
bool parse_transactions(std::istream& in, builder_t& builder)
|
|
{
|
|
TRACE_START(entry_xacts, 1, "Time spent parsing transactions:");
|
|
|
|
bool added = false;
|
|
|
|
while (! in.eof() && (in.peek() == ' ' || in.peek() == '\t')) {
|
|
static char line[MAX_LINE + 1];
|
|
line[0] = '\0';
|
|
in.getline(line, MAX_LINE);
|
|
if (in.eof() || line[0] == '\0')
|
|
break;
|
|
|
|
position_t end_of_line(builder.position());
|
|
end_of_line.offset += std::strlen(line) + 1;
|
|
end_of_line.linenum++;
|
|
|
|
char * p = skip_ws(line);
|
|
if (! *p || *p == '\r' || *p == '\n')
|
|
break;
|
|
|
|
parse_transaction(builder, line, end_of_line);
|
|
added = true;
|
|
}
|
|
|
|
TRACE_STOP(entry_xacts, 1);
|
|
|
|
return added;
|
|
}
|
|
|
|
void parse_entry(std::istream& in,
|
|
builder_t& builder,
|
|
char * line,
|
|
position_t& end_of_line)
|
|
{
|
|
TRACE_START(entry_text, 1, "Time spent preparing entry text:");
|
|
|
|
// First cut up the input line into its various parts
|
|
|
|
char * date = NULL;
|
|
char * date_eff = NULL;
|
|
char * statep = NULL;
|
|
char * code = NULL;
|
|
char * payee = NULL;
|
|
|
|
date = line;
|
|
|
|
char * p = line;
|
|
|
|
while (*p && (std::isdigit(*p) || *p == '/' || *p == '.' || *p == '-'))
|
|
p++;
|
|
assert(*p);
|
|
|
|
if (*p == '=') {
|
|
*p++ = '\0';
|
|
date_eff = p;
|
|
|
|
while (*p && (std::isdigit(*p) || *p == '/' || *p == '.' || *p == '-'))
|
|
p++;
|
|
assert(*p);
|
|
} else {
|
|
*p++ = '\0';
|
|
}
|
|
|
|
p = skip_ws(p);
|
|
|
|
if (*p == '*' || *p == '!') {
|
|
statep = p;
|
|
p++; *p++ = '\0';
|
|
|
|
p = skip_ws(p);
|
|
}
|
|
|
|
if (*p == '(') {
|
|
code = ++p;
|
|
while (*p && *p != ')')
|
|
p++;
|
|
assert(*p);
|
|
*p++ = '\0';
|
|
|
|
p = skip_ws(p);
|
|
}
|
|
|
|
payee = p;
|
|
|
|
p = payee + (std::strlen(payee) - 1);
|
|
while (p > payee && std::isspace(*p))
|
|
p--;
|
|
|
|
if (std::isspace(*(p + 1)))
|
|
*++p = '\0';
|
|
|
|
TRACE_STOP(entry_text, 1);
|
|
|
|
// Setup the details for this node
|
|
|
|
TRACE_START(entry_details, 1, "Time spent parsing entry details:");
|
|
|
|
builder.push_attr(DATE_ATTR, date);
|
|
|
|
if (date_eff)
|
|
builder.push_attr(EFF_DATE_ATTR, date_eff);
|
|
|
|
if (statep) {
|
|
switch (*statep) {
|
|
case '*':
|
|
builder.push_attr(CLEARED_ATTR, "yes");
|
|
break;
|
|
case '!':
|
|
builder.push_attr(PENDING_ATTR, "yes");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (code)
|
|
builder.push_attr(CODE_ATTR, code);
|
|
|
|
builder.begin_node(ENTRY_NODE);
|
|
|
|
builder.begin_node(PAYEE_NODE, true);
|
|
assert(payee);
|
|
builder.append_text(*payee != '\0' ? payee : "<Unspecified payee>");
|
|
builder.end_node(PAYEE_NODE, end_of_line);
|
|
|
|
TRACE_STOP(entry_details, 1);
|
|
|
|
// Parse all the transactions associated with this entry
|
|
|
|
if (! parse_transactions(in, builder))
|
|
throw_(parse_error, "Entry has no transactions");
|
|
|
|
builder.end_node(ENTRY_NODE);
|
|
}
|
|
|
|
bool textual_parser_t::test(std::istream& in) const
|
|
{
|
|
char buf[5];
|
|
|
|
in.read(buf, 5);
|
|
if (std::strncmp(buf, "<?xml", 5) == 0)
|
|
throw_(parse_error, "Ledger file contains XML data, but format was not recognized");
|
|
|
|
in.clear();
|
|
in.seekg(0, std::ios::beg);
|
|
assert(in.good());
|
|
return true;
|
|
}
|
|
|
|
std::size_t textual_parser_t::parse(std::istream& in,
|
|
const path& pathname,
|
|
builder_t& builder)
|
|
{
|
|
TRACE_START(parsing_total, 1, "Total time spent parsing text:");
|
|
|
|
INFO("Parsing file '" << pathname.string() << "'");
|
|
|
|
builder.begin_node(JOURNAL_NODE);
|
|
|
|
std::size_t count = 0;
|
|
|
|
while (in.good() && ! in.eof()) {
|
|
static char line[MAX_LINE + 1];
|
|
in.getline(line, MAX_LINE);
|
|
if (in.eof())
|
|
break;
|
|
|
|
position_t end_of_line(builder.position());
|
|
end_of_line.offset += std::strlen(line) + 1;
|
|
end_of_line.linenum++;
|
|
|
|
//PUSH_CONTEXT();
|
|
|
|
switch (line[0]) {
|
|
case '\0':
|
|
case '\r':
|
|
break;
|
|
|
|
case ' ':
|
|
case '\t': {
|
|
char * p = skip_ws(line);
|
|
if (*p && *p != '\r')
|
|
throw_(parse_error, "Line begins with whitespace");
|
|
break;
|
|
}
|
|
|
|
case 'i':
|
|
case 'I': {
|
|
string date(line, 2, 19);
|
|
|
|
char * p = skip_ws(line + 22);
|
|
char * n = next_element(p, true);
|
|
|
|
builder.push_attr(TIME_ATTR, date);
|
|
builder.push_attr(ACCOUNT_ATTR, p);
|
|
builder.begin_node(CHECKIN_NODE, true);
|
|
builder.append_text(n);
|
|
builder.end_node(CHECKIN_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case 'o':
|
|
case 'O': {
|
|
string date(line, 2, 19);
|
|
|
|
char * p = skip_ws(line + 22);
|
|
char * n = next_element(p, true);
|
|
|
|
builder.push_attr(TIME_ATTR, date);
|
|
builder.push_attr(ACCOUNT_ATTR, p);
|
|
builder.begin_node(CHECKIN_NODE, true);
|
|
builder.append_text(n);
|
|
builder.end_node(CHECKIN_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case 'D': { // specifies default commodity flags
|
|
builder.push_attr(TEMPLATE_ATTR, skip_ws(line + 1));
|
|
builder.push_node(COMMODITY_TEMPLATE_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case 'A': // a default account for unbalanced xacts
|
|
builder.push_attr(NAME_ATTR, skip_ws(line + 1));
|
|
builder.push_node(DEFAULT_ACCOUNT_NODE, end_of_line);
|
|
break;
|
|
|
|
case 'C': // a set of conversions
|
|
if (char * p = std::strchr(line + 1, '=')) {
|
|
*p++ = '\0';
|
|
builder.push_attr(FROM_ATTR, skip_ws(line + 1));
|
|
builder.push_attr(TO_ATTR, p);
|
|
builder.push_node(COMMODITY_CONVERSION_NODE, end_of_line);
|
|
} else {
|
|
throw_(parse_error, "Conversion entry (code C) must follow the format X=Y");
|
|
}
|
|
break;
|
|
|
|
case 'P': { // a pricing entry
|
|
char * date_field_ptr = skip_ws(line + 1);
|
|
char * time_field_ptr = next_element(date_field_ptr);
|
|
if (! time_field_ptr)
|
|
throw_(parse_error, "Pricing entry (code P) is missing arguments");
|
|
string date_field = date_field_ptr;
|
|
|
|
char * symbol_and_price;
|
|
moment_t datetime;
|
|
|
|
if (std::isdigit(time_field_ptr[0])) {
|
|
symbol_and_price = next_element(time_field_ptr);
|
|
if (! symbol_and_price)
|
|
throw_(parse_error, "Pricing entry (code P) is missing a symbol name");
|
|
} else {
|
|
symbol_and_price = time_field_ptr;
|
|
}
|
|
|
|
builder.push_attr(DATE_ATTR, date_field_ptr);
|
|
builder.push_attr(TIME_ATTR, time_field_ptr);
|
|
|
|
string symbol;
|
|
commodity_t::parse_symbol(symbol_and_price, symbol);
|
|
|
|
builder.push_attr(SYMBOL_ATTR, symbol);
|
|
builder.push_attr(PRICE_ATTR, skip_ws(symbol_and_price));
|
|
builder.push_node(PRICE_HISTORY_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case 'N': { // don't download prices
|
|
char * p = skip_ws(line + 1);
|
|
|
|
string symbol;
|
|
commodity_t::parse_symbol(p, symbol);
|
|
|
|
builder.push_attr(SYMBOL_ATTR, symbol);
|
|
builder.push_node(COMMODITY_NOMARKET_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case 'Y': // set current year
|
|
builder.push_attr(YEAR_ATTR, skip_ws(line + 1));
|
|
builder.push_node(CURRENT_YEAR_NODE, end_of_line);
|
|
break;
|
|
|
|
case 'h':
|
|
case 'b':
|
|
case ';': // comment
|
|
// jww (2007-05-12): Read in the comment and save it
|
|
break;
|
|
|
|
case '@':
|
|
case '!': { // directive
|
|
char * p = next_element(line);
|
|
string word(line + 1);
|
|
|
|
builder.push_attr(NAME_ATTR, word);
|
|
builder.push_attr(ARG_ATTR, p);
|
|
builder.push_node(DIRECTIVE_NODE, end_of_line);
|
|
break;
|
|
}
|
|
|
|
case '-': // option setting
|
|
throw_(parse_error, "Option settings are not allowed in journal files");
|
|
|
|
case '=': { // automated entry
|
|
builder.begin_node(AUTO_ENTRY_NODE);
|
|
builder.begin_node(RULE_NODE, true);
|
|
builder.append_text(skip_ws(line + 1));
|
|
builder.end_node(RULE_NODE);
|
|
|
|
builder.set_position(end_of_line);
|
|
|
|
if (! parse_transactions(in, builder))
|
|
throw_(parse_error, "Automated entry has no transactions");
|
|
|
|
builder.end_node(AUTO_ENTRY_NODE);
|
|
break;
|
|
}
|
|
|
|
case '~': // period entry
|
|
builder.begin_node(PERIOD_ENTRY_NODE);
|
|
builder.begin_node(PERIOD_NODE, true);
|
|
builder.append_text(skip_ws(line + 1));
|
|
builder.end_node(PERIOD_NODE);
|
|
|
|
builder.set_position(end_of_line);
|
|
|
|
if (! parse_transactions(in, builder))
|
|
throw_(parse_error, "Repeating entry has no transactions");
|
|
|
|
builder.end_node(PERIOD_ENTRY_NODE);
|
|
break;
|
|
|
|
default:
|
|
TRACE_START(entries, 1, "Time spent handling entries:");
|
|
parse_entry(in, builder, line, end_of_line);
|
|
count++;
|
|
TRACE_STOP(entries, 1);
|
|
break;
|
|
}
|
|
|
|
//POP_CONTEXT(builder_context(builder));
|
|
}
|
|
|
|
builder.end_node(JOURNAL_NODE);
|
|
|
|
TRACE_STOP(parsing_total, 1);
|
|
|
|
return count;
|
|
}
|
|
|
|
} // namespace ledger
|