393 lines
10 KiB
C++
393 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2003-2009, 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 <system.hh>
|
|
|
|
#include "times.h"
|
|
|
|
namespace ledger {
|
|
|
|
int start_of_week = 0;
|
|
optional<std::string> input_date_format;
|
|
std::string output_datetime_format = "%Y-%m-%d %H:%M:%S";
|
|
std::string output_date_format = "%Y-%m-%d";
|
|
|
|
namespace {
|
|
const char * formats[] = {
|
|
"%y/%m/%d",
|
|
"%Y/%m/%d",
|
|
"%m/%d",
|
|
"%Y/%m",
|
|
"%y.%m.%d",
|
|
"%Y.%m.%d",
|
|
"%m.%d",
|
|
"%Y.%m",
|
|
"%y-%m-%d",
|
|
"%Y-%m-%d",
|
|
"%m-%d",
|
|
"%Y-%m",
|
|
"%a",
|
|
"%A",
|
|
"%b",
|
|
"%B",
|
|
"%Y",
|
|
NULL
|
|
};
|
|
|
|
bool parse_date_mask(const char * date_str, std::tm& result)
|
|
{
|
|
if (input_date_format) {
|
|
std::memset(&result, -1, sizeof(std::tm));
|
|
if (strptime(date_str, input_date_format->c_str(), &result))
|
|
return true;
|
|
}
|
|
for (const char ** f = formats; *f; f++) {
|
|
std::memset(&result, -1, sizeof(std::tm));
|
|
if (strptime(date_str, *f, &result))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool quick_parse_date(const char * date_str, std::tm& result, const int year)
|
|
{
|
|
if (! parse_date_mask(date_str, result))
|
|
return false;
|
|
|
|
result.tm_hour = 0;
|
|
result.tm_min = 0;
|
|
result.tm_sec = 0;
|
|
|
|
if (result.tm_mday == -1)
|
|
result.tm_mday = 1;
|
|
|
|
if (result.tm_mon == -1) {
|
|
result.tm_mon = 0;
|
|
|
|
if (result.tm_mday > (CURRENT_DATE().day() - 1))
|
|
result.tm_mon = 11;
|
|
}
|
|
|
|
if (result.tm_year == -1) {
|
|
result.tm_year = (year == -1 ? int(CURRENT_DATE().year()) : year) - 1900;
|
|
|
|
if (year == -1 && result.tm_mon > (CURRENT_DATE().month() - 1))
|
|
result.tm_year--;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
int string_to_day_of_week(const std::string& str)
|
|
{
|
|
if (str == _("sun") || str == _("sunday") || str == "0")
|
|
return 0;
|
|
else if (str == _("mon") || str == _("monday") || str == "1")
|
|
return 1;
|
|
else if (str == _("tue") || str == _("tuesday") || str == "2")
|
|
return 2;
|
|
else if (str == _("wed") || str == _("wednesday") || str == "3")
|
|
return 3;
|
|
else if (str == _("thu") || str == _("thursday") || str == "4")
|
|
return 4;
|
|
else if (str == _("fri") || str == _("friday") || str == "5")
|
|
return 5;
|
|
else if (str == _("sat") || str == _("saturday") || str == "6")
|
|
return 6;
|
|
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
|
|
datetime_t parse_datetime(const char * str, int)
|
|
{
|
|
std::tm when;
|
|
std::memset(&when, -1, sizeof(std::tm));
|
|
if (strptime(str, "%Y/%m/%d %H:%M:%S", &when))
|
|
return posix_time::ptime_from_tm(when);
|
|
else
|
|
return datetime_t();
|
|
}
|
|
|
|
date_t parse_date(const char * str, int current_year)
|
|
{
|
|
std::tm when;
|
|
quick_parse_date(str, when, current_year);
|
|
return gregorian::date_from_tm(when);
|
|
}
|
|
|
|
date_t interval_t::first(const optional<date_t>& moment)
|
|
{
|
|
if (! is_valid(begin)) {
|
|
// Find an efficient starting point for the upcoming while loop. We want
|
|
// a date early enough that the range will be correct, but late enough
|
|
// that we don't spend hundreds of thousands of loops skipping through
|
|
// time.
|
|
assert(moment);
|
|
|
|
if (months > 0 || years > 0) {
|
|
begin = date_t(moment->year(), gregorian::Jan, 1);
|
|
} else {
|
|
begin = date_t(*moment - gregorian::days(400));
|
|
|
|
// jww (2009-02-21): Add support for starting a week on any day
|
|
if (weekly) { // move it to a Sunday
|
|
while (begin.day_of_week() != start_of_week)
|
|
begin += gregorian::days(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
date_t quant(begin);
|
|
|
|
if (moment && *moment >= quant) {
|
|
date_t temp;
|
|
while (*moment >= (temp = increment(quant))) {
|
|
if (quant == temp)
|
|
break;
|
|
quant = temp;
|
|
}
|
|
}
|
|
return quant;
|
|
}
|
|
|
|
date_t interval_t::increment(const date_t& moment) const
|
|
{
|
|
date_t future(moment);
|
|
|
|
if (years) future += gregorian::years(years);
|
|
if (months) future += gregorian::months(months);
|
|
if (days) future += gregorian::days(days);
|
|
|
|
return future;
|
|
}
|
|
|
|
namespace {
|
|
void parse_inclusion_specifier(const string& word,
|
|
date_t * begin,
|
|
date_t * end)
|
|
{
|
|
struct std::tm when;
|
|
|
|
if (! parse_date_mask(word.c_str(), when))
|
|
throw_(date_error, _("Could not parse date mask: %1") << word);
|
|
|
|
when.tm_hour = 0;
|
|
when.tm_min = 0;
|
|
when.tm_sec = 0;
|
|
when.tm_isdst = -1;
|
|
|
|
bool saw_year = true;
|
|
bool saw_mon = true;
|
|
bool saw_day = true;
|
|
|
|
if (when.tm_year == -1) {
|
|
when.tm_year = CURRENT_DATE().year() - 1900;
|
|
saw_year = false;
|
|
}
|
|
if (when.tm_mon == -1) {
|
|
when.tm_mon = 0;
|
|
saw_mon = false;
|
|
} else {
|
|
saw_year = false; // don't increment by year if month used
|
|
}
|
|
if (when.tm_mday == -1) {
|
|
when.tm_mday = 1;
|
|
saw_day = false;
|
|
} else {
|
|
saw_mon = false; // don't increment by month if day used
|
|
saw_year = false; // don't increment by year if day used
|
|
}
|
|
|
|
if (begin) {
|
|
*begin = gregorian::date_from_tm(when);
|
|
if (end)
|
|
*end = interval_t(saw_day ? 1 : 0, saw_mon ? 1 : 0,
|
|
saw_year ? 1 : 0).increment(*begin);
|
|
}
|
|
else if (end) {
|
|
*end = gregorian::date_from_tm(when);
|
|
}
|
|
}
|
|
|
|
inline void read_lower_word(std::istream& in, string& word) {
|
|
in >> word;
|
|
for (int i = 0, l = word.length(); i < l; i++)
|
|
word[i] = static_cast<char>(std::tolower(word[i]));
|
|
}
|
|
|
|
void parse_date_words(std::istream& in, string& word,
|
|
date_t * begin, date_t * end)
|
|
{
|
|
string type;
|
|
|
|
bool mon_spec = false;
|
|
char buf[32];
|
|
|
|
if (word == _("this") || word == _("last") || word == _("next")) {
|
|
type = word;
|
|
if (! in.eof())
|
|
read_lower_word(in, word);
|
|
else
|
|
word = _("month");
|
|
} else {
|
|
type = _("this");
|
|
}
|
|
|
|
if (word == _("month")) {
|
|
time_t now = to_time_t(CURRENT_TIME());
|
|
std::strftime(buf, 31, "%B", localtime(&now));
|
|
word = buf;
|
|
mon_spec = true;
|
|
}
|
|
else if (word == _("year")) {
|
|
int year = CURRENT_DATE().year();
|
|
std::sprintf(buf, "%04d", year);
|
|
word = buf;
|
|
}
|
|
else if (word == _("today")) {
|
|
if (begin)
|
|
*begin = CURRENT_DATE();
|
|
if (end) {
|
|
*end = CURRENT_DATE();
|
|
*end += gregorian::days(1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
parse_inclusion_specifier(word, begin, end);
|
|
|
|
if (type == _("last")) {
|
|
if (mon_spec) {
|
|
if (begin)
|
|
*begin = interval_t(0, -1, 0).increment(*begin);
|
|
if (end)
|
|
*end = interval_t(0, -1, 0).increment(*end);
|
|
} else {
|
|
if (begin)
|
|
*begin = interval_t(0, 0, -1).increment(*begin);
|
|
if (end)
|
|
*end = interval_t(0, 0, -1).increment(*end);
|
|
}
|
|
}
|
|
else if (type == _("next")) {
|
|
if (mon_spec) {
|
|
if (begin)
|
|
*begin = interval_t(0, 1, 0).increment(*begin);
|
|
if (end)
|
|
*end = interval_t(0, 1, 0).increment(*end);
|
|
} else {
|
|
if (begin)
|
|
*begin = interval_t(0, 0, 1).increment(*begin);
|
|
if (end)
|
|
*end = interval_t(0, 0, 1).increment(*end);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void interval_t::parse(std::istream& in)
|
|
{
|
|
string word;
|
|
|
|
while (! in.eof()) {
|
|
read_lower_word(in, word);
|
|
if (word == _("every")) {
|
|
read_lower_word(in, word);
|
|
if (std::isdigit(word[0])) {
|
|
int quantity = lexical_cast<int>(word);
|
|
read_lower_word(in, word);
|
|
if (word == _("days"))
|
|
days = quantity;
|
|
else if (word == _("weeks")) {
|
|
days = 7 * quantity;
|
|
weekly = true;
|
|
}
|
|
else if (word == _("months"))
|
|
months = quantity;
|
|
else if (word == _("quarters"))
|
|
months = 3 * quantity;
|
|
else if (word == _("years"))
|
|
years = quantity;
|
|
}
|
|
else if (word == _("day"))
|
|
days = 1;
|
|
else if (word == _("week")) {
|
|
days = 7;
|
|
weekly = true;
|
|
}
|
|
else if (word == _("month"))
|
|
months = 1;
|
|
else if (word == _("quarter"))
|
|
months = 3;
|
|
else if (word == _("year"))
|
|
years = 1;
|
|
}
|
|
else if (word == _("daily"))
|
|
days = 1;
|
|
else if (word == _("weekly")) {
|
|
days = 7;
|
|
weekly = true;
|
|
}
|
|
else if (word == _("biweekly"))
|
|
days = 14;
|
|
else if (word == _("monthly"))
|
|
months = 1;
|
|
else if (word == _("bimonthly"))
|
|
months = 2;
|
|
else if (word == _("quarterly"))
|
|
months = 3;
|
|
else if (word == _("yearly"))
|
|
years = 1;
|
|
else if (word == _("this") || word == _("last") || word == _("next") ||
|
|
word == _("today")) {
|
|
parse_date_words(in, word, &begin, &end);
|
|
}
|
|
else if (word == _("in")) {
|
|
read_lower_word(in, word);
|
|
parse_date_words(in, word, &begin, &end);
|
|
}
|
|
else if (word == _("from") || word == _("since")) {
|
|
read_lower_word(in, word);
|
|
parse_date_words(in, word, &begin, NULL);
|
|
}
|
|
else if (word == _("to") || word == _("until")) {
|
|
read_lower_word(in, word);
|
|
parse_date_words(in, word, NULL, &end);
|
|
}
|
|
else {
|
|
parse_inclusion_specifier(word, &begin, &end);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace ledger
|